======= PROCESSING - WEAVING =======

**Porteur de projet :** Margot Goutières\\
**Projet :** par hasard\\
**Date :** mars 2020\\
**Contexte :** cours processing\\
**
Lien vers le projet :** [[wiki:projets:par-hasard:weaving:accueil]]


===== 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.\\

{{:wiki:projets:3.png |}}\\ 


----

====== 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**)

{{ :wiki:projets:processing-hasard.mp4 |}}

{{:wiki:projets:capture.png |}}
{{:wiki:projets:capture1.png |}}
{{:wiki:projets:capture2.png |}}\\



====== 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**
{{ :wiki:projets:zip_weaving.zip |}}

====== 5. Programme ======


<code>
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();
}
</code>