• Porteur(s) du projet : Mauffrey Léa
• Date : 14/01/2019
• Licence : libre
• Contexte : Cours de Processing avec Damien Muti

Ce Programme a pour but de représenter graphiquement des principes de base de la physique quantique pour les rendre accessibles au public. Le programme doit être projeté sur l'affiche qui se compose de trois titres. Chacun des titres est associé à un bouton qui déclenche à la fois le texte explicatif et l'animation associé.

Le programme génère plusieurs balles, qui représente les particules en physique quantique, qui vont changer de comportement en fonction du bouton pressé.

L'affiche reprend les couleurs des particules dans mon code. AU centre de chaque cercle bleu il y aura un des capteurs qui affichera le code et le texte qui correspond au titre à coté du bouton.

Le code déclenche des animations et du textes associé au titre écrit sur l'affiche. La touche B stop la particule dans son déplacement et la fait vibrer autour de sa position (x,y). + apparition du texte correspondant à un monde non localisé.

La touche V stop la vibration et fait avancer les particules. + apparition du texte correspondant à Un monde en mouvement.

La touche N fait augmenter la taille des particules. + apparition du texte correspondant à La décohérence.

//Déclaration des variables globales

ArrayList<Particule> particule;  //tableau de particule
int N=10;  //nombre de particule de base dans le tableau
int t=0;  //variable de temps 
PFont police;  //création de texte  
boolean t1=false;  //texte 1
boolean t2=false;  //texte 2
boolean t3=false;  //texte 3


////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void setup() { 
  // initialisation des variables globales et des paramètres d'affichage
  
  size(800, 800);   //taille

  t = millis();   //variable temps = en milliseconde  

  police=loadFont("Avenir-Light-20.vlw");   //importation de la typographie
  textFont(police);

  background(255);
  noStroke();


  // création d'un TABLEAU DYNAMIQUE VIDE (ArrayList)
  particule = new ArrayList<Particule>();

  // remplir le tableau avec des particules
  for (int i=0; i<N; i++) {
    Particule p = creerParticule();   // création d'une nouvelle particule bleu
    particule.add(p);   // ajouter une particule au tableau
  }
  for (int i=0; i<N; i++) {
    Particule p = creerParticule2();   // création d'une nouvelle particule violette
    particule.add(p);   // ajouter une particule au tableau
  }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void draw() {
 // rafraichissement du contenu de la fenêtre d'affichage

  fill(255);   //couleur du rectangle
  rect(0, 0, width, height);   //fond 

   // afficher le texte si la variable t1, t2, t3 = true
  if (t1 == false) {
    text(" ", 100, 100);
  } else {
    fill(0);
    textSize(15);
    String s = "La théorie quantique décrit un monde étrange, où l'on découvre que la matière qui constitue tout notre univers, et qui semble pourtant bien localisée dans l'espace est en fait « étendue » quelque part. Les repères comme ici et là-bas, qui sont si cohérents à notre échelle perdent toute signification dès qu'on franchit les limites du monde atomique.";
    text(s, 350, 150, 250, 500);
    // text(afficher string s, position x, position y, largueure du bloc de texte, longueur du bloc de text)
  }

  if (t2 == false) {
    text(" ", 100, 100);
  } else {
    fill(0);
    textSize(15);
    String s = "Le monde quantique échappe à toutes nos tentatives de le délimiter dans une zone précise de l'espace : lorsqu'on essaie de mesurer la position d'une particule avec une grande précision, l'information sur sa vitesse est incertaine.";
    text(s, 150, 330, 250, 500);
  }

  if (t3 == false) {
    text(" ", 100, 100);
  } else {
    fill(0);
    textSize(15);
    String s = "Notre monde est composé de milliards de particules élémentaires. Et plus il y a de particules, plus les interactions entre elles sont fréquentes, bien évidemment. Ces interactions brisent en quelque sorte la symétrie du monde quantique : il se produit alors ce qu'on appelle la « décohérence ».";
    text(s, 400, 450, 250, 500);
  }
  // pour chaque particule p du tableau particule (arraylist)
  for ( Particule p : particule) {
    p.afficher();//exécuter la fonction afficher de la class (class_particule) 
    p.avancer();//exécuter la fonction avancer de la class  
    p.rebondir();//exécuter la fonction rebondir de la class 
    p.nbFrameApresRebond ++;//augmenter la valeur de 1
  }
  // pour chaque particule p du tableau particule (arraylist)
  for ( Particule p : particule) {
    p.afficher();   //exécuter la fonction afficher de la class (class_particule) 
    p.avancer();   //exécuter la fonction avancer de la class  
    p.rebondir();   //exécuter la fonction rebondir de la class 
    p.nbFrameApresRebond ++;   //augmenter la valeur de 1
  }

  // augmenter le nb de balle si le temps proportionel a 1s
  t = millis();
  println(t%1000);


  if (particule.get(0).vibration == false) {   //si la var vibration est fausse
    if (t%1000 <20) {   // si le quotient de t strictement inférieur (division euclidienne) 
      // créer une nouvelle particule
      Particule p = creerParticule();
      particule.add(p);   //ajoute une particule (bleu)
    }
    if (t%1000 <20) {
      // créer une nouvelle particule
      Particule p = creerParticule2();
      particule.add(p);   //ajoute une particule (violette)
    }
  }
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void keyPressed() {
  
  //activer les différentes animations en utilisant des touches
  
  //si la touche b est pressé 
  if (key == 'b' || key== 'B') {
    for ( Particule p : particule) {
      p.vibration=true;   //vibration est vrai : les particules vibrent (cf :class_particule)
      p.x0=p.x;   //mémorisation de la position x
      p.y0=p.y;   //mémorisation de la position y
    }
    t1=true;   //t1 est vrai : le texte 1 s'affiche 
    t2=false;
    t3=false;
  }
  
  //si la touche v est pressé
  if (key == 'v' || key== 'V') {

    for ( Particule p : particule) {
      p.vibration=false;   // les particules bouge normalement (annulation code touche b) 
      
    }
    t1=false;   // le texte 1 disparaît
    t2=true;   // le texte 2 s'affiche
    t3=false;
  }

//si la touche n est pressé
  if (key == 'n' || key== 'N') {
    for ( Particule p : particule) {
      if (p.nbFrameApresRebond>2) {   //si le nombre d'image après le rebond est supérieur à 2
        p.d++ ;   // le diamètre de la particule augmente 
      }
      t1=false;
      t2=false;   // le texte 2 disparaît
      t3=true;   //le texte 3 s'affiche
    }
  }
}

Cette class sert à créer les particules du tableau. L'attribut de la class correspond à toutes les variables appliqué à l'objet. Le constructeur sert à créer un espace mémoire pour les valeurs des variables et les méthodes servent créer les comportements des particules, dans ce cas afficher la particule faire avancer la particule et faire rebondir la particule.

class Particule {

  //attribut des particules

  color c;   // couleur
  int x;   // position x de la particule
  int y;   // position y de la particule
  int x0;   // valeur pour garder en mémoire la position de x 
  int y0;   // valeur pour garder en mémoire la position de y
  int dx;   // déplacement x
  int dy;   // déplacement y
  int d;   //diamètre 
  int nbFrameApresRebond;   // nb de frames après rebonds d'une particule
  boolean vibration = false;   // variable 



  //constructeur, instancier un espace mémoire pour les valeurs de la particule
  Particule(int _x, int _y, int _dx, 
    int _dy, int _d, color _c) {
    x = _x;
    y = _y;
    dx = _dx;
    dy = _dy;
    d = _d;
    c = _c;
    x0 = 0; // la valeur est directement instencier, à 0 de base
    y0 = 0;
    nbFrameApresRebond =0;
  }
  
  
  //méthodes
  //créer particlue
  void afficher() {
    fill(c);
    ellipse(x, y, d, d);
  }


  // avancer
  void avancer() {
    if (vibration == false) {   //on verifie que la variable vibration = false (fausse)
      x += dx;   // equivalent x = x + dx
      y = y + dy;
    }   // si vibration est fausse on ajoute la valeur du déplacement à celle de la position de x et d'y
        // on fait donc avancer la particule
    else {   // sinon, si la variable vibration = true (vrai)
      x = x0+ floor(random(-2, 2));   // random sur la position
      y = y0 + floor(random(-2, 2));
    }
  }


  //rebondir
  void rebondir() {
    if ((x+d/2 >= width) || (x-d/2 <= 0)) {   // bord droit
      dx = dx * (-1); // sens inverse
      nbFrameApresRebond=0;
    }

    if ((y+d/2 >= height) || (y-d/2 <= 0)) {   // bord droit
      dy = dy * (-1); // sens inverse
      nbFrameApresRebond = 0;
     
    }
   
  }

}

Création de particule

Particule creerParticule () {
  
  Particule a;
  
  //instanciation (création) de la particule
  int x = width/2; // position x
  int y =height/2; // position y
  int dx = floor(random(-2, 2));   //déplacement x
  int dy = floor(random(-2, 2));   //déplacement y
  int d = floor(random(10, 30));   //diamètre de la particule
  color c = color(random(50,200),235,205);   //couleur avec la valeur rouge(rgb) aléatoire entre 50 et 200
  a= new Particule(x, y, dx, dy, d, c);

  return a;
}

Création d'une autre particule de couleur différente

Particule creerParticule2 () {
  
  Particule a;
  
  //instanciation (création) de la balle
  int x = width/2;   // position x
  int y =height/2;   // position y
  int dx = floor(random(-2, 2));   //déplacement x
  int dy = floor(random(-2, 2));   //déplacement y
  int d = floor(random(10, 30));   //diamètre 
  color c = color(random(80,130),61,145);   //couleur(variation de couleur sur le rouge)
  a= new Particule(x, y, dx, dy, d, c);

  return a;