Cecilia4_score_python

							Génération de partitions à l'aide de scripts Python

La fenêtre Python dans la section Score permet de générer la partition à partir
d'un script écrit en Python, un environnement beaucoup plus puissant pour
la conception d'algorithmes musicaux. La syntaxe est celle de Python et tous les
modules standards peuvent être utilisés. En général, les quelques fonctions spécifiques
à Cecilia permettent de générer simplement la suite d'évènements désirées.

Variables réservées

p2, p3, p4, p5, ..., p20 sont des variables réservées qui servent à spécifier les
différents paramètres des évènements générés. En assignant une valeur à ces
paramètres (à l'aide du symbole =), on construit la ligne de paramètres pour
l'instrument courant (voir forInst).

ex:

forInst(1)
p2 = 0
p3 = 30
p4 = 440

Ce script ajoutera la ligne "i1 0 30 440" à la partition.

Il est possible de spécifier des listes aux différents paramètres afin de générer
plusieurs évènements d'un coup. La longueur de la liste donnée à la variable p2
détermine le nombre d'évènements à créer. À chaque nouvel évènement, on
avance d'une position dans chaque liste. Si une liste arrive au bout, elle revient
à 0 et reprend le compte jusqu'à ce que la liste en p2 soit épuisée.

ex:

forInst(1)
p2 = [0, .5, 1, 1.5, 2, 2.5]
p3 = 1
p4 = [440, 220, 330]

Ce script ajoutera les lignes suivantes à la partition:

i1   0 1 440
i1   .5 1 220
i1   1 1 330
i1   1.5 1 440
i1   2 1 220
i1   2.5 1 330


Description des fonctions fournies par Cecilia

addLine(str)

Cette fonction ajoute une ligne (str) textuelle dans la partition. Particulièrement
utile pour ajouter les tables nécessaires.
str est une chaîne de caractères définie entre guillemets.

ex:

addLine("f1 0 8192 10 1")


forInst(x)

Cette fonction sert à spécifier à quel instrument seront assignés les paramètres
définis par la suite. Chaque fois que cette fonction est appelée, les évènements
de l'instrument précédent sont générés avec les valeurs courantes des variables
(p2, p3, ...) puis celles-ci sont réinitialisées, prêtes à se faire assigner de nouvelles
valeurs pour l'instrument demandé.

ex:

forInst(1)
p2 = 0
p3 = 30
p4 = 440
p5 = 5000

forInst(10)
p2 = [0,10,20]
p3 = 10
p4 = [220, 330, 440]

forInst(99)
p2 = 0
p3 30

Les lignes suivantes seront ajoutées à la partition:

i1 0 30 440 5000
i10 0 10 220
i10 10 10 330
i10 20 10 440
i99 0 30

Il est tout à fait possible de placer cette fonction dans une boucle pour
automatiser la création d'évènements sur plusieurs instruments:

for i in range(5):
    forInst(i+1)
    p2 = i * 0.1
    p3 = 1
    p4 = random.randint(220, 440)

Ce script donnera des résultats différents chaque fois qu'il sera lancé. Voici
un exemple de partition générée:

i1 0 1 287
i2   .1   1   345
i3   .2   1   240
i4   .3   1   403
i5   .4   1   333

La fonction randint du module Python random pige un nouvel entier, à
l'intérieur de l'ambitus spécifié en argument, chaque fois qu'elle est appelée.
Les valeurs pigées seront donc différentes chaque fois que le module sera
joué.


createTable(tableNum, initTime, tableSize, gen, *args)

Cette fonction sert à insérer une définition de table dans la partition.

Paramètre:

tableNum: numéro de la table
initTime: temps de chargement
tableSize: taille de la table en échantillons
gen: numéro de la routine GEN à utiliser
*args: tous les arguments suivants seront ajoutés à la suite de la ligne

ex:

createTable(1, 0, 8192, 10, 1, 0, .33, 0, .2, 0, .143, 0, .111)

La ligne suivante (une onde carrée) sera ajoutée à la partition:

f1 0 8192 10 1 0 .33 0 .2 0 .143 0 .111


getUserValue(str)

Cette fonction retourne la valeur intiale d'un objet d'interface graphique.

str est le nom de l'objet spécifié entre guillemets.

ex:

n = getUserValue("num_of_notes")
for i in range(n):
    forInst(1)
    p2 = 0
    p3 = 10
    p4 = random.randint(195, 205)

Ce script est un classique pour la génération d'un chorus. Le slider d'entier
"num_of_notes" permet de spécifier directement combien de tours de boucle
le script doit faire, c'est à dire combien d'évènements doivent être générés.


midiToHertz(pitch)
Retourne la fréquence en Hertz correspondant au pitch Midi donné en argument.

ex:

pits = [60, 62, 64, 65, 67, 69, 71, 72]
for i in range(200):
    forInst(1)
    p2 = i * .1
    p3 = .5
    p4 = midiToHertz(random.choice(pits))

Ce script construit une mélodie aléatoire sur la gamme de DO majeur.
random.choice pige une valeur au hasard dans une liste donnée et
midiToHertz convertit cette valeur en Hertz.


midiToTranspo(pitch, centralkey=60)

Retourne le facteur de transposition correspondant à un pitch Midi
et une note Midi centrale donnés en argument. La note centrale
est la note où le facteur de transposition sera 1.

ex:

pits = [60, 62, 64, 65, 67, 69, 71, 72]
for i in range(200):
    forInst(1)
    p2 = i * .1
    p3 = .5
    p4 = midiToTranspo(random.choice(pits))

Même script que l'exemple précédeant mais en affectant p4 à un facteur
de transposition tel que la vitesse de lecture d'un fichier son avec diskin2.
Ce système assure que les facteurs de transposition choisis donneront des
transpositions correspondant à la gamme de DO majeur.


Objets de génération aléatoire

Les fonctions suivantes servent à créer des objets de génération aléatoire
contrôlée. Les objets créés possèdent la méthode next permettant de
demander une nouvelle valeur, en lien avec les valeurs précédentes.

drunk(mini=0, maxi=127)

Retourne un objet générateur de marche aléatoire. Les arguments servent
à spécifier les limites de la génération (des entiers).

ex:

d = drunk(mini=48, maxi=102)
for i in range(200):
    pitch = d.next()
    forInst(1)
    p2 = i*.05
    p3 = .1
    p4 = midiToHertz(pitch)


droneAndJump(mini=0, maxi=127)

Retourne un objet générateur "drone and jump". La première note pigée,
considérée comme le drone, est répétée systématiquement. De temps en
temps, une nouvelle note, le jump, vient s'immiscer dans la génération,
puis c'est le retour à la note initiale.
Les arguments servent à spécifier les limites de la génération (des entiers).

ex:

d = droneAndJump(mini=48, maxi=102)

for i in range(200):
    pitch = d.next()
    forInst(1)
    p2 = i*.05
    p3 = .1
    p4 = midiToHertz(pitch)


repeater(mini=0, maxi=127)

Retourne un objet générateur qui répète plusieurs fois une note avant d'en
piger une autre.
Les arguments servent à spécifier les limites de la génération (des entiers).

ex:

d = repeater(mini=48, maxi=102)

for i in range(200):
    pitch = d.next()
    forInst(1)
    p2 = i*.05
    p3 = .1
    p4 = midiToHertz(pitch)


loopseg(mini=0, maxi=127)

Retourne un objet générateur qui boucle un certain nombre de fois un
segment de mélodie généré selon une marche aléatoire. Après avoir
effectué ses tours de boucle (choisi au hasard entre 3 et 8 tours), un
nouveau segment est généré et bouclé.
Les arguments servent à spécifier les limites de la génération (des entiers).
ex:

d = loopseg(mini=48, maxi=102)

for i in range(200):
    pitch = d.next()
    forInst(1)
    p2 = i*.05
    p3 = .1
    p4 = midiToHertz(pitch)


Méthode pour les objets générateurs

next(maxStepSize=-2):

Cette méthode retourne une nouvelle valeur de l'objet et permet de
spécifier le saut maximum possible, en nombre d'entiers.
Si maxStepSize est négatif, les répétitions sont interdites.