PROCESSING - WEAVING

Porteur de projet : Margot Goutières
Projet : par hasard
Date : mars 2020
Contexte : cours processing
Lien vers le projet : weaving

Commentaire général - Damien MUTI DESGROUAS

Le plan du Wiki est parfaitement respecté. L’énoncé de la situation et des intensions sont très claires. Vous donnez un certain nombre de visuels associé qui facilitent la compréhension de vos intensions. Vous donnez le lien sur vos recherches de pratiques plastique qui constituent un gros travail. Le fonctionnement du programme est aussi bien expliqué. Vous avez fait un bon travail de recherche sur OpenProcessing dont vous donnez le programme de référence. Vous donnez une vidéo de fonctionnement (un peu lourde : la mettre sur Youtube?) et des visuels très efficaces. Vous donnez le fichier .zip de votre projet (très lourd : 76MO !!!). Il n’est pas utile d’y mettre l’application exécutable, seul le fichier .pde est suffisant et infiniment moins lourd. Vous donnez le programme et brièvement les modifications apportées. Il mériterait d’être un peu plus commenté et surtout d’expliquer un peu plus son algorithme. Il faudrait aussi que le programme donné dans le dossier compressé comporte les commentaires. Globalement il s’agit d’une bonne présentation qui se lit facilement. Le contrat est rempli.

1. Introduction

Je me suis intéressée aux traces de vie que peut avoir le temps sur le tissu, que ce soit de l'usure, des taches, des traces, des déchirements ou encore l'étiolement. Tout cela dû au hasard bien sur et celui ci représente une mémoire de vie, un témoin du temps qui passe.

2. Intention

Je souhaite réaliser un visuel qui sera projeté sur l'objet final (de ma pratique plastique) avec des visuels d'altération avec un programme aléatoire sur Processing. Le but étant d'obtenir tissage noir sur fond blanc qui au passage du curseur commence à s'étioler, s'effilocher, comme si nous étions acteurs de son altération. Plus nous appauvrissons le tissage, plus nous laissons entrevoir l'oeuvre sur laquelle est projetée le programme.

3. Présentation et fonctionnement du programme

J'ai obtenu le résultat escompté (Muti : expliquer cette phrase qui arrive brutalement) et j'ai donc ajouté un bruitage de tissu qui se déchire pour un côté plus immersif. Le code dessine des lignes balisées de point noirs pouvant évoluer en fonction de comment est placé le curseur de la souris. Il simule le déchirement du tissu, c'est pour cela que ce programme processing correspond en tout point avec la thématique de mon projet de pratique plastique. Je voulais représenter l’altération suite au passage de quelque chose. Chaque fois que le programme est ouvert, l'altération n'est jamais la même. Nous sommes acteur de l'altération et nous pouvons décider de comment va s'étioler le tissage.

J'ai aussi modifié les couleurs du programme de base.

Test en vidéo du rendu final (mauvaise qualité car c'est une capture d'écran mais c'est surtout pour le son)

processing-hasard.mp4

4. Les sources et les liens du programme

Codage, je me suis inspiré d'un programme trouvé sur openprocessing: https://www.openprocessing.org/sketch/529890 Zip zip_weaving.zip

5. Programme

Grid grid;
float ran = 9;
// flottement aléatoire
void setup() {
size(900, 900, P2D);
noFill();
grid = new Grid(70, 13);
// ici on gère la taille de la grille et le fait qu'il n'y a pas de remplissage
}
void draw() {
grid.render();
}
class Grid {
int d;
int o;
PVector a, dir;
ArrayList points = new ArrayList();
int l =-1;
// arraylist est un stockage de variable infini, il stocke les points de tissage
Grid(int d_, int o_) {
points.clear();
d=d_;
o=o_;
for (int i=0; i<d*d; i++) {
PVector s = new PVector(i/d*o, i%d*o);
points.add(s);
}
}
int di() {
return d;
}
int od() {
return o;
// La ligne qui donne pour consigne de « renvoyer une valeur » est celle qui contient le return
}
void render() {
background(#FFFFFF);
stroke(#050000);
//ici on traduit la largeur et la hauteur (width/2-(d*o/2), height/2-(d*o/2));
for (int i=0; i<d*d; i++) {
PVector pr = (PVector)points.get(i);
a = new PVector(mouseX, mouseY);
PVector dir = PVector.sub(a, pr);
dir.normalize();
dir.div(dist(mouseX, mouseY, pr.x, pr.y)/12);
dir.limit(2.3);
pr.sub(dir);
// cette partie là sert à régler les paramètres du passage du curseur
}
for (int i=0; i<d*(d-1)-1; i++) {
if ((i+1)%d>1) {
PVector pt = (PVector)points.get(i);
PVector pt2 = (PVector)points.get(i+d);
PVector pt3 = (PVector)points.get(i+d+1);
PVector pt4 = (PVector)points.get(i+1);
line_new(pt.x, pt.y, pt2.x, pt2.y);
// une classe pour décrire un vecteur à deux ou trois dimensions, en particulier un vecteur euclidien (également connu sous le nom géométrique). Un vecteur est une entité qui a à la fois une amplitude et une direction. Cependant, le type de données stocke les composants du vecteur (x, y pour 2D et x, y, z pour 3D). L'amplitude et la direction sont accessibles via les méthodes mag () et cap () .
}
}
}
}
void line_new(float xx, float yy, float xx1, float yy1) {
PVector x = new PVector(xx, yy);
PVector x1 = new PVector(xx1, yy1);
PVector v = PVector.sub(x1, x);
float d = x1.dist(x);
pushMatrix();
translate(xx, yy);
PVector v1 = new PVector(v.x, v.y);
PVector v2 = new PVector(v.x, v.y);
PVector v3 = new PVector(v.x, v.y);
v1.setMag(d);
v2.setMag(d/4);
v3.setMag(d-d/4);
bezier(0, 0, random(v2.x-ran, v2.x+ran), random(v2.y-ran, v2.y+ran), random(v3.x-ran, v3.x+ran), random(v3.y-ran, v3.y+ran), v1.x, v1.y);
strokeWeight(5);
point(random(v1.x-2, v1.x+2), random(v1.y-2, v1.y+2));
strokeWeight(1);
popMatrix();
}