Simon Bouvier - Tarkos : Différence entre versions

De Design numérique
Aller à : navigation, rechercher
(Postulat initial)
 
(62 révisions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
=Projets=
+
 
==Projet d'introduction au terminal==
+
=Tarkos=
 +
==Postulat initial==
  
 
→ L'idée de base était de travailler autour de la poésie sonore, d'inculper les problématiques sonores, de répétitions des syllabes, des jeux des sonorités, de bégaiement propre à des poètes tels que Vincent Tarkos et Ghérasim Luca.
 
→ L'idée de base était de travailler autour de la poésie sonore, d'inculper les problématiques sonores, de répétitions des syllabes, des jeux des sonorités, de bégaiement propre à des poètes tels que Vincent Tarkos et Ghérasim Luca.
  
<embedvideo service="youtube">https://www.youtube.com/watch?v=fRuMzUtL90M</embedvideo>
+
<embedvideo service="youtube">https://www.youtube.com/watch?v=KGW5dxXZFTY</embedvideo>
 
<embedvideo service="youtube">https://www.youtube.com/watch?v=16ltchO5Vpw</embedvideo>
 
<embedvideo service="youtube">https://www.youtube.com/watch?v=16ltchO5Vpw</embedvideo>
 +
 +
==Les outils==
  
 
J'ai tout d'abord cherché les possibilités pour faire parler le terminal <br>
 
J'ai tout d'abord cherché les possibilités pour faire parler le terminal <br>
  
espeak qui permet de moduler la vitesse, la hauteur de la voix..<br>
+
====Faire parler la machine====
 +
:*[http://espeak.sourceforge.net/commands.html/ Espeak] qui permet de moduler la vitesse, la hauteur de la voix. <br>
 +
:*[https://www.tekrevue.com/tip/make-your-mac-talk-say-command/ La commande Say] qui possède une voix un peu plus naturelle <br>
 +
 
 +
J'ai ensuite chercher la fonction qui me permettrait de mélanger les mots/les lettres pour travailler une répétition qui s'altère, se désagrège
 +
 
 +
====Modifier le texte====
 +
 
 +
:*[https://ss64.com/bash/fold.html/ fold -w1] permet de mettre les lettres en colonne, </br>
 +
:*[https://shapeshed.com/unix-shuf/ gshuf] permet de mélanger, soit les lettres quand couplé avec fold ou simplement les mots.</br>
 +
:*[https://en.wikipedia.org/wiki/Words_(Unix)/ -n1 /usr/share/dict/words] permet également d'ajouter un mot aléatoire à la poèsie aléatoire ainsi formé, me permettant de renouveler le sens et d'enrichir le sens et la diversité syllabique du poème. La question est de savoir comment je pourrais par exemple former des mots avec un minimum de syllabes similaires au mots de bases, pour former un ensemble qui reste tout de même cohérent. </br>
 +
:*Je peux aussi jouer avec la fonction de remplacer  [http://www.linux-france.org/article/memo/node10.html/ tr] afin de changer les lettres du mot ainsi généré pour changer l'acoustique selon ce que je souhaite selon les sonorités de base.</br>
 +
Le problème est que les fonctions citées précédemment permettent de mélanger les lettres et les mots, produisant donc rapidement un charabia. Dans un souci de sonorité, je préférais donc travailler sur les syllabes, une répétition syllabique qui peu à peu à-vient jouer sur les mots, entre répétition, bégaiement et renouvellement.
 +
 
 +
====Travailler les syllabes====
 +
 
 +
:On m'a donc orienté vers la fonction [https://www.quennec.fr/trucs-astuces/syst%C3%A8mes/gnulinux/scripts/d%C3%A9couper-un-mot-en-syllabes/ syllabes.sh] , celle-ci peut découper les mots en syllabes automatiquement, me permettant, combiné avec la fonction gshuf de re-modifier un mot en gardant une forme de structure et de sonorités cohérentes.
 +
 
 +
==Mise en application==
 +
====Mélanger les lettres et reformer des mots différents====
 +
 
 +
cat "tarkos.sh" | fold -w1 | gshuf | tr -d "\n" </code>
 +
 
 +
====Ajouter un mot, mélanger les mots et les réécrire dans le fichier====
 +
 
 +
gshuf -n1 /usr/share/dict/words >> "tarkos.sh" && cat "tarkos.sh" | uniq | gshuf | tr "\n" " " | cut -c-100 </code>
 +
 
 +
====création d'une fonction qui permette d'utiliser syllabe====
 +
 
 +
Le script [https://www.quennec.fr/trucs-astuces/syst%C3%A8mes/gnulinux/scripts/d%C3%A9couper-un-mot-en-syllabes/ syllabes.sh] est formulé de la syntaxe suivante : </br>
 +
$ ./syllabes.sh mot1 mot2 mot3 mot4 etc etc ... </code>
 +
 
 +
ce qui nous donne : </br>
 +
:[[Fichier:Syllabes_.png|500px]] </br>
 +
 
 +
Il a donc fallut ajuster l'utilisation pour que le résultat soit directement inscrit dans le fichier de destination : </br>
 +
traitement=$(./syllabes.sh $(cat tarkos.txt))
 +
echo "$traitement">> tarkos.txt </code>
 +
 
 +
Puis supprimer la ponctuation inutile </br>
 +
#!/bin/bash traitement=$(./syllabes.sh $(cat tarkos.txt))
 +
echo "$traitement"| sed 's/.*=> //g' | tr "-" " " </code>
 +
 
 +
====Doubler les syllabes et les mélanger====
 +
 
 +
On double ensuite ces syllabes en ajoutant un espace entre chacun de ces doublons, on les mets chacun à la ligne, on les mélange pour enfin remettre ces nouvelles syllabes en une seule ligne.
 +
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " "
 +
 
 +
====Travailler autour d'une accélération====
 +
 
 +
J'ai ensuite décidé d'ajouter un temps via la fonction [https://www.cyberciti.biz/faq/linux-unix-sleep-bash-scripting/ sleep] qui permettrait de réduire peu à peu l'attente entre chaque mélange de syllabes.
 +
 
 +
chrono=3
 +
incremant=-1
 +
while [ $chrono -ge 0 ];
 +
    do
 +
        coupe
 +
        sleep $chrono
 +
        chrono=$((chrono+$incremant))
 +
done
 +
 
 +
Cette partie du script permets d'effectuer l'action [[#Doubler les syllabes et les mélanger| ()Coupe]] avec d'abord 3 secondes d'interval, puis deux secondes, une et enfin s'arrêter.
 +
 
 +
==Propositions intermédiaires et progression==
 +
 
 +
====Exemple 1====
 +
On obtient ce script </br>
 +
traitement=$(./syllabes.sh $(cat tarkos.txt))
 +
coupe(){
 +
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " "}
 +
chrono=3
 +
incremant=-1
 +
while [ $chrono -ge 0 ];
 +
    do
 +
        coupe
 +
        say -f tarkos.txt
 +
        sleep $chrono
 +
        chrono=$((chrono+$incremant))
 +
done
 +
 
 +
Celui-ci permets, à partir d'un texte ''(tarkos.txt)'', de découper les mots en syllabes, de doubler les syllabes pour simuler ce bégaiement propres [[#Postulat initial|aux poètes]], mélanger celles-ci pour enfin les afficher dans le terminal.
 +
 
 +
patience poussière
 +
devient
 +
pa siè pous tien ce ce pous tien  re siè pa  re ''(3 secondes)''
 +
ce siè re tien pa pous ce siè tien  re pa pous ''(2 secondes)''
 +
ce pous tien  siè pa pous  re tien pa siè re ce ''(1 secondes)''
 +
pous re ce tien pa ce tien siè pa pous re siè ''(0 secondes)''
 +
 
 +
 
 +
 
 +
----
 +
 
 +
====Exemple 2====
 +
Ici la longueure du texte original reste inchangée, mais je peux également inscrire le résultat du mélange dans le fichier pour redoubler à chaque itération les syllabes. En modifiant simplement :
 +
 
 +
coupe(){
 +
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr
 +
"\n" " " >> tarkos.txt}
 +
 
 +
On obtient un fichier texte :
 +
patience
 +
poussièresiè siè ce pous tien ce  re re pa pa pous tien pa pa  re siè  siè ce tien re tien ce pous pous
 +
pa siè  ce re tien ce tien pous siè  pous pa re  siè re ce tien pa pous pous re ce  tien siè pa
 +
 
 +
je peux également enregistrer directement le rendu
 +
coupe(){
 +
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >> tarkos.txt |
 +
say -o /Users/simonbouvier/desktop/test_output.aiff -f /Users/simonbouvier/desktop/tarko/tarkos.txt}
  
http://espeak.sourceforge.net/commands.html<br>
+
cependant via cette fonction celui-ci ne prends pas en compte les temps de pause
  
→ la commande Say qui possède une voix un peu plus naturelle <br>
+
[https://soundcloud.com/simon-bouvier-180854428/tarkos Ce que ça donne vocalement]
 +
----
  
https://www.tekrevue.com/tip/make-your-mac-talk-say-command/<br>
+
====Exemple 3====
 +
J'ai également travaillé sur la vitesse d'élocution du terminal pour que celle-ci augmente à chaque élocution successive, via la fonction 'say -r $' qui me permet de définir une variable de vitesse.
  
→ j'ai ensuite chercher la fonction qui me permettrait de mélanger les mots/les lettres pour travailler une répétition qui s'altère, se désagrège :  "fold -w1" qui permet de mettre les lettres en colonne, "gshuf" permet de mélanger, soit les lettres quand couplé avec fold ou simplement les mots.
+
#!/bin/bash
 +
traitement=$(./syllabes.sh $(cat tarkos.txt))
 +
coupe(){
 +
  echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >> tarkos.txt}
 +
chrono=3
 +
incremant=-1
 +
locution=175
 +
incremantel=50
 +
while [ $chrono -ge 0 ];
 +
    do
 +
        coupe
 +
        say -r $locution -f tarkos.txt
 +
        say -o /Users/simonbouvier/desktop/tarkos.aiff -f tarkos.txt
 +
        sleep $chrono
 +
        chrono=$((chrono+$incremant))
 +
        locution=$((locution+$incremantel))
 +
done
 +
----
  
→ cat "tarkos.txt" | fold -w1 | gshuf | tr -d "\n" permets donc de mélanger les lettres et de reformer des mots différents.
+
====Exemple 4====
  
la fonction shuf -n1 /usr/share/dict/words permet également d'ajouter un mot aléatoire à la poèsie aléatoire ainsi formé, me permettant de renouveler le sens et d'enrichir le sens et la diversité syllabique du poème. La question est de savoir comment je pourrais par exemple former des mots avec un minimum de syllabes similaires au mots de bases, pour former un ensemble qui reste tout de même cohérent. Je peux aussi jouer avec la fonction de remplacer (tr) afin de changer les lettres du mot ainsi généré pour changer l'acoustique selon ce que je souhaite selon les sonorités de base.
+
Finalement, j'ai travaillé la boucle pour qu'elle effectue un aller-retour, avec une pause qui diminue entre chaque élocution qui devient elle de plus en plus rapide jusquarriver à une pause égal à 0, pour ensuite faire la boucle inverse où le temps de pause augmente et la vitesse d'élocution diminue.
 +
Ci-dessous la valeur du chrono en seconde suivi de la vitesse d'élocution.
  
Le problème est que les fonctions citées précédemment permettent de mélanger les lettres et les mots, produisant donc rapidement un charabia. Dans un souci de sonorité, je préférais donc travailler sur les sonorités, une répétition syllabique qui peu à peu à-vient jouer sur les mots, entre répétition, bégaiement et renouvellement. On m'a donc orienté vers la fonction syllabes.sh (https://www.quennec.fr/trucs-astuces/syst%C3%A8mes/gnulinux/scripts/d%C3%A9couper-un-mot-en-syllabes), celle-ci peut découper les mots en syllabes automatiquement, me permettant, combiné avec la fonction gshuf de re-modifier un mot en gardant une forme de structure et de sonorités cohérentes.
+
[[Fichier:Capture d’écran 2018-12-18 à 14.12.28.png|Capture d’écran 2018-12-18 à 14.12.28.png|300px]]
  
 +
#!/bin/bash
 +
traitement=$(./syllabes.sh $(cat tarkos2.txt))
 +
coupe(){ echo "$traitement" | gsed 's/.*=> //g' | tr "-" " " | gsed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >>
 +
tarkos2.txt; }
 +
chrono=5
 +
increment=-1
 +
locution=175
 +
incremantel=50
 +
    while <nowiki> [[ "$chrono" -ge 0 && "$chrono" -le 5 ]];</nowiki>
 +
    do
 +
    coupe
 +
    echo $locution
 +
    echo $chrono
 +
    say -r $locution -f tarkos2.txt
 +
    sleep $chrono
 +
    chrono=$(( chrono+increment ))
 +
    locution=$((locution+$incremantel))
 +
        if <nowiki> [[ "$chrono" -eq 1 ]]; </nowiki>
 +
        then
 +
            increment=1
 +
            incrementiel=-75
 +
        fi
 +
done
  
{{#invoke:Bananas|hello}}
+
==Améliorations==
 +
===répétitions===
 +
#nombre de syllabes répétées aléatoire
 +
#certaines lettres disparaissent lors du dédoublement
 +
===diction===
 +
#la vitesse de locution accélère jusqu'à des extrêmes où les mots ne seraient plus distinguables.

Version actuelle datée du 29 mars 2019 à 17:09

Tarkos

Postulat initial

→ L'idée de base était de travailler autour de la poésie sonore, d'inculper les problématiques sonores, de répétitions des syllabes, des jeux des sonorités, de bégaiement propre à des poètes tels que Vincent Tarkos et Ghérasim Luca.

Les outils

J'ai tout d'abord cherché les possibilités pour faire parler le terminal

Faire parler la machine

  • Espeak qui permet de moduler la vitesse, la hauteur de la voix.
  • La commande Say qui possède une voix un peu plus naturelle

J'ai ensuite chercher la fonction qui me permettrait de mélanger les mots/les lettres pour travailler une répétition qui s'altère, se désagrège

Modifier le texte

  • fold -w1 permet de mettre les lettres en colonne,
  • gshuf permet de mélanger, soit les lettres quand couplé avec fold ou simplement les mots.
  • -n1 /usr/share/dict/words permet également d'ajouter un mot aléatoire à la poèsie aléatoire ainsi formé, me permettant de renouveler le sens et d'enrichir le sens et la diversité syllabique du poème. La question est de savoir comment je pourrais par exemple former des mots avec un minimum de syllabes similaires au mots de bases, pour former un ensemble qui reste tout de même cohérent.
  • Je peux aussi jouer avec la fonction de remplacer tr afin de changer les lettres du mot ainsi généré pour changer l'acoustique selon ce que je souhaite selon les sonorités de base.

Le problème est que les fonctions citées précédemment permettent de mélanger les lettres et les mots, produisant donc rapidement un charabia. Dans un souci de sonorité, je préférais donc travailler sur les syllabes, une répétition syllabique qui peu à peu à-vient jouer sur les mots, entre répétition, bégaiement et renouvellement.

Travailler les syllabes

On m'a donc orienté vers la fonction syllabes.sh , celle-ci peut découper les mots en syllabes automatiquement, me permettant, combiné avec la fonction gshuf de re-modifier un mot en gardant une forme de structure et de sonorités cohérentes.

Mise en application

Mélanger les lettres et reformer des mots différents

cat "tarkos.sh" | fold -w1 | gshuf | tr -d "\n" 

Ajouter un mot, mélanger les mots et les réécrire dans le fichier

gshuf -n1 /usr/share/dict/words >> "tarkos.sh" && cat "tarkos.sh" | uniq | gshuf | tr "\n" " " | cut -c-100 

création d'une fonction qui permette d'utiliser syllabe

Le script syllabes.sh est formulé de la syntaxe suivante :

$ ./syllabes.sh mot1 mot2 mot3 mot4 etc etc ... 

ce qui nous donne :

Syllabes .png

Il a donc fallut ajuster l'utilisation pour que le résultat soit directement inscrit dans le fichier de destination :

traitement=$(./syllabes.sh $(cat tarkos.txt)) 
echo "$traitement">> tarkos.txt 

Puis supprimer la ponctuation inutile

#!/bin/bash traitement=$(./syllabes.sh $(cat tarkos.txt)) 
echo "$traitement"| sed 's/.*=> //g' | tr "-" " " 

Doubler les syllabes et les mélanger

On double ensuite ces syllabes en ajoutant un espace entre chacun de ces doublons, on les mets chacun à la ligne, on les mélange pour enfin remettre ces nouvelles syllabes en une seule ligne.

echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " "

Travailler autour d'une accélération

J'ai ensuite décidé d'ajouter un temps via la fonction sleep qui permettrait de réduire peu à peu l'attente entre chaque mélange de syllabes.

chrono=3
incremant=-1
while [ $chrono -ge 0 ];
   do
       coupe
       sleep $chrono
       chrono=$((chrono+$incremant))
done

Cette partie du script permets d'effectuer l'action ()Coupe avec d'abord 3 secondes d'interval, puis deux secondes, une et enfin s'arrêter.

Propositions intermédiaires et progression

Exemple 1

On obtient ce script

traitement=$(./syllabes.sh $(cat tarkos.txt))
coupe(){
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " "}
chrono=3
incremant=-1
while [ $chrono -ge 0 ];
   do
       coupe
       say -f tarkos.txt
       sleep $chrono
       chrono=$((chrono+$incremant))
done

Celui-ci permets, à partir d'un texte (tarkos.txt), de découper les mots en syllabes, de doubler les syllabes pour simuler ce bégaiement propres aux poètes, mélanger celles-ci pour enfin les afficher dans le terminal.

patience poussière

devient

pa siè pous tien ce ce pous tien  re siè pa  re (3 secondes)
ce siè re tien pa pous ce siè tien   re pa pous (2 secondes)
ce pous tien  siè pa pous  re tien pa siè re ce (1 secondes)
pous re ce tien pa ce tien siè pa pous re siè (0 secondes)



Exemple 2

Ici la longueure du texte original reste inchangée, mais je peux également inscrire le résultat du mélange dans le fichier pour redoubler à chaque itération les syllabes. En modifiant simplement :

coupe(){
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr 
"\n" " " >> tarkos.txt}

On obtient un fichier texte :

patience
poussièresiè siè ce pous tien ce   re re pa pa pous tien pa pa  re siè  siè ce tien re tien ce pous pous 
pa siè  ce re tien ce tien pous siè  pous pa re  siè re ce tien pa pous pous re ce  tien siè pa 

je peux également enregistrer directement le rendu

coupe(){
echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >> tarkos.txt | 
say -o /Users/simonbouvier/desktop/test_output.aiff -f /Users/simonbouvier/desktop/tarko/tarkos.txt}

cependant via cette fonction celui-ci ne prends pas en compte les temps de pause

Ce que ça donne vocalement


Exemple 3

J'ai également travaillé sur la vitesse d'élocution du terminal pour que celle-ci augmente à chaque élocution successive, via la fonction 'say -r $' qui me permet de définir une variable de vitesse.

#!/bin/bash
traitement=$(./syllabes.sh $(cat tarkos.txt))
coupe(){
  echo "$traitement" | sed 's/.*=> //g' | tr "-" " " | sed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >> tarkos.txt}
chrono=3
incremant=-1
locution=175
incremantel=50
while [ $chrono -ge 0 ];
   do
       coupe
       say -r $locution -f tarkos.txt
       say -o /Users/simonbouvier/desktop/tarkos.aiff -f tarkos.txt
       sleep $chrono
       chrono=$((chrono+$incremant))
       locution=$((locution+$incremantel))
done

Exemple 4

Finalement, j'ai travaillé la boucle pour qu'elle effectue un aller-retour, avec une pause qui diminue entre chaque élocution qui devient elle de plus en plus rapide jusqu'à arriver à une pause égal à 0, pour ensuite faire la boucle inverse où le temps de pause augmente et la vitesse d'élocution diminue. Ci-dessous la valeur du chrono en seconde suivi de la vitesse d'élocution.

Capture d’écran 2018-12-18 à 14.12.28.png

#!/bin/bash
traitement=$(./syllabes.sh $(cat tarkos2.txt))
coupe(){ echo "$traitement" | gsed 's/.*=> //g' | tr "-" " " | gsed 's/\(.*\)/\1 \ \1/g' | tr " " "\n" | gshuf | tr "\n" " " >> 
tarkos2.txt; }
chrono=5
increment=-1
locution=175
incremantel=50
   while  [[ "$chrono" -ge 0 && "$chrono" -le 5 ]];
   do
    coupe
    echo $locution
    echo $chrono
    say -r $locution -f tarkos2.txt
    sleep $chrono
    chrono=$(( chrono+increment ))
    locution=$((locution+$incremantel))
       if  [[ "$chrono" -eq 1 ]];  
       then
           increment=1
           incrementiel=-75
       fi
done

Améliorations

répétitions

  1. nombre de syllabes répétées aléatoire
  2. certaines lettres disparaissent lors du dédoublement

diction

  1. la vitesse de locution accélère jusqu'à des extrêmes où les mots ne seraient plus distinguables.