Affiche interactive : Un monde quantique

Porteur(s) du projet : Mauffrey Léa

Date : 14/01/2019

Licence : libre

Contexte : Cours de Processing avec Damien Muti

Description

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é.

Affiche

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.

Algorithme

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.

Programme

//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
}
}
}

Class

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;