Page 2

12 janvier 2019

Arbres chantants

Graphes animés.

Mes séquenceurs en forme de graphe pourraient également générer leur propre accompagnement musical lorsqu’ils croissent.

Structure et composition

Comment ces arbres produiront-ils de la musique ? Comment cette musique sera-t-elle définie à l’intérieur de l’arbre ? Par exemple, un arbre pourrait être doté d’une tonique et d’une armature.

La notion de « marcheur » est aussi très importante. Ce devrait être le marcheur qui « consulte » l’arbre et produit la musique. De cette façon, puisque l’on voit le marcheur se promener, le lien visuel entre son mouvement et la musique est plus intéressant que si la musique provenait inexplicablement de l’arbre seul. Enfin, la musique sans marcheur pourrait aussi être intéressante, mais je vais commencer par les marcheurs.

Un marcheur pourrait commencer au tronc de l’arbre en produisant la tonique. Lorsqu’il arrive à un embranchement, il pourra créer un nouveau marcheur. Ces marcheurs pourront ensuite s’engager dans les branches de l’arbre, et générer des sons simultanément.

Les notes pourraient être générées par les embranchements ou par les branches elles-mêmes. La longueur d’une note pourrait être déterminée par la longueur du segment sur lequel le marcheur se trouve — cependant, ces longueurs pourraient changer pendant que le marcheur avance, ce qui créerait des sons atonaux.

Pour l’instant, les notes seront représentées par les embranchements. Ça me semble une façon naturelle de commencer l’expérience. Donc, les objets Segment dont la propriété children est plus grande que 1 représentent un embranchement. Ce serait plus simple qu’un marcheur « s’endorme » lorsqu’il atteint un embranchement. Avant de s’endormir, il crée de nouveaux marcheurs (un pour chaque children du Segment) et leur lègue sa mémoire. Ou alors il ne s’endort pas et s’engage toujours dans la première branche de la liste children. De toute façon, un marcheur et les marcheurs qu’il a généré doivent être absolument égaux, il n’y aura pas de hiérarchie chez ces marcheurs.

// All the walkers would refer to a single instance of Song.
// Then, when a walker modulates the song, it will be modulated
// for all walkers.
let mixo = new Song({
    scale: "E mixolydian",
    currentChord: 1
});
// Define the music inside the Walker itself?
// The melody notes should represent degrees on the scale,
// starting at 1 being the tonic,
// not semitones with zero-based numbering.

//branchingModulo
let walker = new Walker({
    scale: "E mixolydian",
    melodies: [[1, 4, 6, 7],
               [1, 5, 8, 9]],
    currentMelodyIndex: [0, 2],
    speed: 3,
    branchingModulo: 4,
    walkingDepth: 0,
    song: mixo
});

// A walker could then have any number of methods
// that would define and alter its behaviour.

walker.branch = function(s) {
    // What happens when the Walker meets a branching Segment
    // s.children
    this.makeNote();
    this.currentSegment = s.children[0];
};

walker.sing = function() {
    // What happens when the Walker meets a branching Segment
    this.sing();
};

L’avancée d’un marcheur

Le niveau d’avancée d’un marcheur sur son segment doit être une valeur entre 0 et 1. Donc, sa vitesse est aussi un nombre entre 0 et 1. Sa vitesse est ajoutée à son niveau d’avancée à chaque pas (niveau qui plafonne à 1). La position du marcheur est ensuite calculée par interpolation linéaire entre les deux extrémités du segment.

Librairies musicales

Afin de soutenir ces liens entre la structure mathématique (et spatiale) de mes arbres et les accompagnements musicaux qu’ils généreront, je vais utiliser deux librairies JavaScript à vocation musicale: Tonal et Teoria. Ces outils devraient me permettre de manipuler des notions de théorie musicale plus aisément.

Une note à moi-même : afin d’utiliser l’extension Tonal.Key de Tonal.js dans un fureteur (plutôt que sur un serveur Node.js), j’ai dû utiliser Browserify en l’invoquant de cette manière :

node ./node_modules/.bin/browserify main.js -o bundle.js

Contexte

Cette note de blog fait partie de mon projet de recherche Vers un cinéma algorithmique, démarré en avril 2018. Je vous invite à consulter la toute première note du projet pour en apprendre davantage.

17 décembre 2018

Quadrilatères flous

Études géométriques avec WebGL.

Dessiner des formes floues avec WebGL n’est pas simple. Par défaut, toutes les formes créées sont très précises et leurs contours bien définis. Comme je cherche à créer des animations aux ambiances brumeuses et incertaines, je suis en train de créer quelques premiers outils pour me permettre de dessiner du flou avec WebGL.

Dessiner des cercles flous ne s’est pas avéré trop compliqué, puisqu’une simple fonction de distance par rapport au centre du cercle peut être calculée aisément par le gpu. Le dessin de formes plus complexes me demande cependant d’en apprendre beaucoup plus sur WebGL, une technologie que je connais encore peu.

J’ai commencé par les quadrilatères. J’ai créé un système avec lequel je peux définir un rectangle principal, qui sera formé par les triangles a et b que l’on voit dans le diagramme en haut à gauche de mes notes crayonnées.

12 décembre 2018

Volées d’oiseaux artificiels

Une première plongée dans la programmation à la volée.

Ce projet constitue ma toute première expérience de programmation à la volée, c’est-à-dire que le programme a été conçu pour être modifié en temps réel. L’animation de ce programme est réalisée avec p5.js et WebGL, et la musique est produite avec SuperCollider. La musique utilise également des échantillons de piano distribués librement.

Le principe sur lequel cette animation repose est la simulation du comportement d’une volée d’oiseaux, ces oiseaux artificiels que l’on appelle boids en anglais. J’ai d’abord appris l’existence de ces simulations grâce aux vidéos de Daniel Shiffman. Shiffman a traité à plusieurs reprises de ce sujet, mais cette vidéo en particulier m’a inspiré cette animation.

Le projet peut être visionné sur YouTube et une version plus courte (qui contient, à mon avis, la meilleure partie de la vidéo) est présente sur mon fil Twitter.

25 novembre 2018

Parcours de graphes

Explorations déterministes et objectifs non définis.

Je veux implémenter l’algorithme de parcours en profondeur dans mes systèmes de séquenceurs en forme de graphe. Je verrai de quelles façons je peux me servir de cet algorithme pour créer des formes visuelles et des séquences musicales intéressantes. Je ne sais pas vraiment comment je pourrais utiliser cet algorithme pour son usage habituel (parcourir un graphe afin de déterminer s’il existe un chemin d’un sommet à un autre), mais pour l’instant, j’imagine qu’il pourrait me servir à créer des motifs déterministes à l’intérieurs de mes graphes. D’une façon générale, j’aimerais voir comment je pourrais traverser mes graphes de façons déterministes, puisque mes premières expérimentations ne sont que des parcours stochastiques.

Ordre de sélection des voisins à visiter

Une question importante qui n’est pas nécessairement soulevée par l’algorithme de parcours en profondeur, c’est l’ordre dans lequel sont sélectionnés les voisins à visiter. Et pour cause : ça n’a normalement pas d’importance. Enfin… je ne crois pas. Répondre à la question « y a-t-il un chemin entre ces deux sommets ? » n’implique pas de choisir ces sommets à visiter dans un ordre particulier. Mais dans mon cas, comme je m’intéresse aux formes que j’obtiendrai en appliquant cet algorithme, et comme je cherche une solution déterministe, l’ordre de sélection sera important.

17 novembre 2018

Programmation à la volée

Notes de travail pour une application en chantier.

Je suis en train de fabriquer une application Node.js qui me permettra de faire de la programmation improvisée. L’expression anglaise “live coding” est plus souvent utilisée. Wikipedia la traduit par « programmation à la volée » ou « programmation juste-à-temps ». Je ne suis pas enchanté par ces traductions mais faute de mieux, ça fera. Elle contient deux champs de texte CodeMirror, la première qui contrôle un serveur SuperCollider, et la seconde qui controle un sketch p5.js.

Pour créer cette application, j’ai utilisé une bonne quantité de code écrit pour Prynth, un logiciel créé par Ivan Franco, Harish Venkatesan, Ajin Tom et Antoine Maiorca. Prynth est distribué avec une licence Creative Commons Cc By-Nc-Sa 4.0. J’ai également repris un peu de code écrit par Olivia Jack pour son logiciel Hydra, qui est distribué avec une licence Gnu Affero Gpl v3.0.

Mon application s’appelle Les environs. Elle peut être téléchargée sur GitHub.

4 novembre 2018

Les spirales brumeuses

Premiers pas avec WebGl et les “shaders”.

Je commence mon apprentissage d’un sujet immense : la programmation de “shaders” WebGL. Le code source de ces premières expériences peut être consulté sur GitHub.

17 octobre 2018

Séquenceurs en forme de graphe

Imaginer différentes manières de lier image et musique.

En apprenant à travailler avec les graphes, il m’est venu l’idée de m’en servir pour créer des animations qui combineraient du mouvement visuel et du mouvement sonore. L’idée m’est aussi venue en voyant le séquenceur circulaire dont Sam Tarakajian parle sur sa chaîne YouTube consacrée à Max/Msp. Une démonstration vidéo de ce projet se trouve sur mon fil Twitter.

28 septembre 2018

Dessins granulaires

Applications du concept de synthèse granulaire à des dessins.

Je suis récemment tombé par hasard sur une chose dont la beauté me foudroie : la synthèse granulaire. Il s’agit d’une méthode qui sert à transformer des sons en les découpant en très petits segments (nommés grains). En faisant des premières expériences de synthèse granulaire, je n’ai pas pu m’empêcher d’imaginer comment ce principe pourrait être utilisé en arts visuels et en cinéma. J’ai fait en partant de cette idée quelques expériences qui se sont avérées très peu concluantes, mais dont je partage tout de même les notes ci-dessous.

19 septembre 2018

Ravines

Un court métrage d’animation fait avec la géométrie des tortues et du bruit de Perlin.

Ce court métrage est sur YouTube.

20 août 2018

Les tortues de Perlin

Croisements divers entre les tortues géométriques de Papert et le bruit de Perlin.

Dans ces expérimentations, je cherche différentes façons de créer des séquences d’instructions pour une tortue géométrique. Utiliser du bruit de Perlin (unidimensionnel ou bidimensionnel) me semble être une idée de départ intéressante.