Fran Lejeune et Jean-Michel Rolland

EN--FR JEAN-MICHEL ROLLAND Arts Numériques

HOME FRAN JIM

DISOBEDIENCE
MUSIQUE GENERATIVE / GENERATIVE MUSIC

Existe en application pour Android : disobedience.apk.

V4 - Latest version / V4 - dernière version :

"Disobedience" est une œuvre de musique générative visualisée où l'ordinateur a le rôle d'interprète. Sur quatre octaves, il décide quelles notes jouer à quel moment. La musique résultante n'a jamais été jouée avant et ne sera jamais jouée à nouveau. Les paramètres originaux, décidés par l'artiste, canalisent la "créativité" de l'ordinateur pour la rendre mélodieuse. Les notes sont matérialisées par des paires de lignes verticales colorées qui se séparent et disparaissent. Les notes basses créent des lignes sur le côté gauche de l'écran tandis que les tons élevés créent des lignes sur le côté droit. Les couleurs vont du rouge au rouge en passant par toutes les couleurs de l'arc-en-ciel, de gauche à droite. Diffusions : o 07-08/2017 : FILE Hypersonica, Sao Paulo (Brésil) o 08/2017 : Espacio Center, Canaries (Espagne) o 09/2017 : Megapolis Festival, Philadelphie (USA)	"Disobedience" is a visualized generative music artwork where the computer has the role of the performer. Over four octaves, it decides which notes to play at the right moment. The resulting music has never been played before and will never be played again. The original parameters, decided by the artist, channel the "creativity" of the computer to make it melodious. The notes are materialized by pairs of colored vertical lines separating and vanishing. Low notes create lines on the left side of the screen while high tones create lines on the right side. The colors go from red to red through all the colors of the rainbow, from left to right. Screenings : o 07-08/2017 : FILE Hypersonica, Sao Paulo (Brazil) o 08/2017 : Espacio Center, Canarias (Spain) o 09/2017 : Megapolis Festival, Philadelphia (USA)
V3:
GENESE Suite à mes différentes expériences en Vjing interactif et en art génératif, je me lance dans la conception d’un travail de musique générative (ou de musique procédurale) avec Processing. Le principe est le suivant : dans un cadre que je lui aurai fourni, l’ordinateur décidera quelles notes jouer à quel moment. Je sais déjà que la principale difficulté sera de laisser assez de marge au hasard sans que le résultat soit trop anarchique. Parce que je suis un artiste plasticien autant qu’un musicien, je créerai des visuels en interaction avec le son. Je commence par une première expérimentation très libre dans laquelle toutes les fréquences comprises entre 110 et 440 hertz sont disponibles. Les notes sont calculées par groupes de trois. Je demande à l’ordinateur, plutôt que d’utiliser une fonction "random" qui génère une valeur complètement au hasard, d’effectuer ses calculs avec la fonction "noise", algorithme appelé bruit de Perlin généralement utilisé pour créer des textures visuelles complexes. Cette fonction renvoie des valeurs comprises entre 0 et 1 qui ont l’air d’être choisies au hasard mais qui obéissent cependant à une logique mathématique. Voici la ligne de code qui génère les notes :	GENESIS Following my different experiences in interactive Vjing and generative art, I'm starting a new generative music (or procedural music) project with processing. Here's the basic principle : in a framework I will have provided, the computer will decide which notes to play at the right moment. I already know the main difficulty will be to let enough randomness without getting a too anarchic result. Because I'm a musician as well as a visual artist, I will create visuals interacting with the sound. I'm beginning with a very free first experiment in which all the frequencies included between 110 and 440 hertz are available. The notes are calculated by groups of three. I'm asking the computer, rather than a "random" function that generates completely random values, to use the "noise" algorithm, also called Perlin noise and generally used to create complex visual textures. This function returns values between 0 and 1 that seem to be chosen randomly but that however obey to a nathematical logic. Here's the line of code that generates the notes :
note[i] = 110 + noise(note[i])*330; DISOBEDIENCE / PREPARATORY WORK #1
En entendant cette expérimentation, je m’aperçois que règne un grand désordre. La cause en est principalement l’utilisation de la totalité des fréquences comprises entre 110 hertz (LA1 - ou LA de la première octave) et 440 hertz (LA3 - ou LA de la troisième octave). En musique occidentale, on utilise pour les instrumentés frettés la gamme tempérée qui comporte douze demi-tons. Pour augmenter une note x0 de n demi-tons, il faut appliquer la formule suivante : f(xn) = x0 * 2n/12. Par exemple, pour obtenir un DO2 à partir d’un LA1, on calcule : note = 110 * 23/12 ou note = 110 * 1,1892 = 130,812 hertz. Dans Processing, voici ce que cela donne, cette fois-ci en utilisant la fonction "random" :	Listening to this experiment, I realize it's a big disorder. The cause of it is mainly that every frequencies between 110 (A1 - or A in the first octave) and 440 (A3 - or A in the third octave) hertz are used. In occidental music, we used for fretted instruments the well-tempered scale that has twelve half-tones. To raise the pitch of a note x0 by a half-tone, one has to apply the following formula : f(xn) = x0 * 2n/12. For example, to get C2 from a A1, we calculate : note = 110 * 23/12 or note = 110 * 1,1892 = 130,812 hertz. In Processing, here's the result, this time with a "random" function :
float facteur = int(random(-13, 13)) /12.0; note[i] = note[i] * pow(2, facteur); DISOBEDIENCE / PREPARATORY WORK #2
J’essaie, à seules fins d’expérimentations, de restreindre le nombre des notes jouées en ne laissant la possibilité à l’ordinateur de ne choisir qu’une note sur trois (LA, DO, MIb, FA#).	I'm now trying, only in an experimental goal, to limit the number of played notes by letting the computer chosing only one note out of three (A, C, Eb, F#).
int valeur = int(random(5))*3; float facteur = valeur/12.0; note[i] = note[i] * pow(2, facteur); DISOBEDIENCE / PREPARATORY WORK #3
Il me semble à présent intéressant de creuser du côté de la segmentation de l’octave en douze demi-tons. Cette règle peut-elle être brisée ? Peut-on imaginer une octave dans laquelle on ferait rentrer plus de douze notes ? Notre oreille, accoutumée à la musique occidentale depuis notre gestation, pourra-t-elle trouver harmonieuse une musique à ce point irrespectueuse ? J'essaie de faire rentrer 16 notes dans une octave :	It seems interesting now to look at the segementation of the octave in twelve half-tones. Can this rule be broken ? Can we imagine an octave in which we would play more than twelve notes ? Can our ear, accustomed to occidental music since our gestation, find harmony in a so disrepectful music? I try to play 16 notes in an octave:
float facteur = int(random(-17, 17))/16.0; note[i] = note[i] * pow(2, facteur);
La gamme qui en résulte comporte avec 4 notes connues (La, Do, Mib et Fa#) et 12 nouvelles notes inconnues.	The resulting range has 4 known notes (A, C, Eb and F#) and 12 new unknown notes.
DISOBEDIENCE / PREPARATORY WORK #4
J’essaie maintenant une octave composée de neuf notes dans laquelle seront présents le La, le Do# et le Fa, plus 6 notes inconnues, en réintroduisant par la même occasion la fonction "noise" :	I'm now trying an octave with nine notes in which we'll have the A, the C# and the F, plus 6 unknown notes, reintroducing by the way the "noise" function :
float facteur = int(map(noise(note[i]), 0, 1, -9, 9))/9.0; note[i] = note[i] * pow(2, facteur); DISOBEDIENCE / PREPARATORY WORK #5
Afin de pouvoir détecter la meilleure solution possible quant au fractionnement de l’octave, je crée une variable que j’appelle "fractions" et j’implémente une commande qui me permettra d’en changer la valeur avec les touches "+" et "-" de mon clavier d’ordinateur :	To be able to chose the best octave segmentation, I create a new variable that I call "fractions" and I add a line of code that will allow me to change the value of "fractions" with the "+" and "-" keys of my computer keyboard :
facteur[i] = int(map(noise(note[i]), 0, 1, -fractions, fractions))/fractions; note[i] = note[i] * pow(2, facteur[i]);
Lors du lancement du programme, une seule note est possible (fractions=1) et je vais pouvoir passer en revue toutes les combinaisons possibles en augmentant au fur et à mesure le nombre de fréquences possibles par octave. Faute de temps, je m’arrêterai à 53 notes par octave...	When I start, only one note is possible (fractions=1) and I will go through all possible combinations by increasing one by one the number of possible frequencies in an octave until I reach 53 notes per octave...
DISOBEDIENCE / PREPARATORY WORK #6
Il est loin d’être facile de trouver de l’harmonie en dehors des sentiers (re)battus... J’ai cependant été intéressé par la fragmentation en 31 notes. J’essaie cette combinaison pour voir si elle tient ses promesses sur la durée :	It's quite difficult to find harmony outside the box... I've been however intersted in the 31 notes segmentation. I'm trying this combination to see if it's worth on a long time :
facteur[i] = int(map(noise(note[i]), 0, 1, -31, 31))/31; note[i] = note[i] * pow(2, facteur[i]); DISOBEDIENCE / PREPARATORY WORK #7
Cette musique me plaît mais je pense que je serai le seul à l’apprécier... J’en reviens donc à notre bonne vieille gamme tempérée pour produire une musique générative écoutable par à peu près tout le monde. En expérimentant, je trouve que, pour le choix des notes, la fonction sin() qui renvoie le sinus d’une valeur donne quelque chose de beaucoup plus intéressant. Voici mon nouveau code :	I like this music but I think I'll be the only one to appreciate it... So I get back to our good old well-tempered scale to produce a generative music that can be listenable by almost everyone. While experimenting, I find that the sin() function (calculates the sinus of a value) returns more interesting sounds for chosing the notes. Here's my new code :
facteur[i] = int(map(sin(map(note[i], 0, 440, 0, TWO_PI)), -1, 1, -12, 12))/12; note[i] = note[i] * pow(2, facteur[i]); DISOBEDIENCE / PREPARATORY WORK #8
Ces deux lignes de code peuvent être simplifiées de la façon suivante :	These two lines can be simplified this way :
note[i] = note[i] * pow(2.0, round(sin((note[i] / 440.0) * TWO_PI)*12)/12.0);
Je souhaite à présent, tout en conservant la fonction sin() pour le calcul des notes, modifier l’échelle de grandeur de cette fonction. Je crée une variable que j’appelle "ecart" et je l’inclue dans mon algorithme :	Now, keeping the sin() function to calculate notes, I wish to modify its scale. I create a variable I call "ecart" and I include it in my algorithm :
note[i] = note[i] * pow(2.0, round(sin((note[i] / 440.0) * TWO_PI)*ecart)/12.0);
Je partirai avec un "ecart" de 6 et l’augmenterai de 1 unité toutes les 30 secondes. Les notes qui résulteront feront toujours partie de la gamme tempérée, c’est uniquement la méthode de calcul qui sera modifiée.	I will begin with an "ecart" of 6 and will increase it one by one every 30 sconds. The resulting notes will still be in the well-tempered scale, it's just the calculation method that changes.
DISOBEDIENCE / PREPARATORY WORK #9
Le choix n’est pas simple mais j’opte pour un écart de 18. Avec ce calcul : La1 devient Mib3 Lab1 devient Mi3 Si1 et Do2 deviennent Fa3 Do#2 et Ré2 deviennent Fa#3 Mib2 et Mi2 deviennent Fa3 Fa2 devient Mi3 Fa#2 devient Mib3 Sol2 devient Do#3 Lab2 devient Si2 La2 reste La2 Sib2 devient Sol2 Si2 devient Mi2 Do3 devient Ré2 Do#3 devient Do2 Ré3, Mib3 et Mi3 deviennent Sib1 Fa3 devient Do2 Fa#3 dvient Mib2 Sol3 devient Lab2 Lab3 devient Ré3 La3 reste La3 Remarques : les trois notes de départ, celles qui vont donner sa particularité à la composition, sont décidées par l’ordinateur par cette itération appelée une seule fois au lancement du programme :	The choice is not easy but I will keep an range of 18. With this method : A1 becomes Eb3 Ab1 becomes E3 B1 and C2 become F3 C#2 and D2 become F#3 Eb2 and E2 become F3 F2 becomes E3 F#2 becomes Eb3 G2 becomes C#3 Ab2 becomes B2 A2 remains A2 Bb2 becomes G2 B2 becomes E2 C3 becomes D2 C#3 becomes C2 D3, Eb3 and E3 become Bb1 F3 becomes C2 F#3 dvient Eb2 G3 becomes Ab2 Ab3 becomes D3 A3 remains A3 Comment : the three very first notes, which are going to give the composition its particularity, are decided by the computer in this iteration called only once at the beginning of the process :
for (int i=0; i<3; i++) { facteur[i] = int(random(-13, 13))/12; note[i] = 110 * pow(2, facteur[i]*2); } DISOBEDIENCE
Il y a donc 24*24*24 = 13 824 possibilités, et autant de "partitions" possibles. La vidéo que je produis dure 10 minutes mais le programme une fois lancé peut durer une éternité sans jamais se répéter. Cela fait de la musique générative pour 13 824 éternités... Je me permets de passer de nombreux détails sous silence pour ne pas alourdir la rédaction de cet essai. Un point important que je n’ai pas abordé est par exemple la durée des notes et l’intervalle de temps entre elles... Si vous avez des questions sur ce travail, vous pouvez me les poser à jim.rolland@free.fr	So there are 24*24*24 = 13 824 possibilities, and as many possible "music sheets". The video I produce lasts 10 minutes but once the process started, it can last an eternity without never repeating itself. It makes generative music for 13 824 eternities... I take the freedom not to give many details in order to avoid making this writing too cumbersome. An important point I haven't talked about is for example the duration of notes and the time interval between them... If you have any question about this piece of work, you can ask them to jim.rolland@free.fr