====== Projets processing ======
OpenCV: Il s'agit d'une librairie processing utilisant un flux d'images pour identifier et tracker des objets, des formes ou des visages en temps réel grâce à ses algorithmes.On utilise les pixels pour reconnaître des paternes qui sont interprétés selon les besoins. Dans ces programmes, c'est le visage de face que l'on reconnait, chaque visage est inscrit dans son tableau pour qu'on lui attribue du code, relatif à sa position sur l'écran.
===== ✔ Yeux qui suivent =====
int nb = 10;
float mx;
float my;
eye [] eye = new eye[nb];
import gab.opencv.*;
import processing.video.*;
import java.awt.*;
Capture video;
OpenCV opencv;
void setup() {
fullScreen();
video = new Capture(this, 640/2, 480/2);
opencv = new OpenCV(this, 640/2, 480/2);
opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);
video.start();
for (int i=0; i1000) {
size = 0;
time = floor(random(800));
x=floor(random(width));
y=floor(random(height));
}
}
}
==== ✔ Yeux qui suivent v2 ====
Pareil mais cette c'est une paire de yeux attribuée à chaque visage qui suit indépendamment cette fois-ci
{{ :wiki:projets:projets:yeux1.png |}}
//import des librairies
import gab.opencv.*;
import processing.video.*;
import java.awt.*;
//initialise openCV
Capture video;
OpenCV opencv;
int nb = 5; //nombre max de paires de yeux
eye [] eye = new eye[nb]; //déclare la classe
void setup() {
fullScreen(); //plein écran
video = new Capture(this, 640/2, 480/2); //déclare vidéo comme capture webcam
opencv = new OpenCV(this, 640/2, 480/2); //déclare openCV
opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE); //déclare le type de tracking
video.start(); //lance la vidéo
for (int i = 0; i < nb; i++) {
eye[i] = new eye(); //instancie les différentes paires
eye[i].set(); //donne des positions aléatoires
}
}
void draw() {
opencv.loadImage(video);//lance la vidéo
image(video, 0, 0);//positionne l'image
background(0);//fond noir
Rectangle[] faces = opencv.detect();//tracking du visage
for (int i = 0; i < nb; i++) { //boucle for effective pour chaque paire
eye[i].shut(); //change l'état des yeux pour les fermer
}
for (int i = 0; i < faces.length; i++) { //boucle for pour chaque instance de visage
eye[i].mx = (((faces[i].x+faces[i].width/2)*6)*-1+width); //définit la position d'un visage sur x
eye[i].my = ((faces[i].y+faces[i].height/2)*4.5);//définit la position d'un visage sur y
//ces valeurs sont ajustées pour transformer la taille de la capture vers un écran 1920x1080
eye[i].open(); //change l'état des yeux pour les fermer(si le visage n'est pas détecté on reste sur la valeur donné par eye.shut)
eye[i].update(); //calcule la position de la pupille
}
for (int i = 0; i < nb; i++) {//boucle for effective pour chaque paire
eye[i].opening();//selon l'état des yeux, va ouvrir ou les fermer
eye[i].display(); // affiche les différents éléments
//eye[i].debug(); //pour voir où est positionné le visage sur l'écran
}
}
void captureEvent(Capture c) {
c.read(); //lit la vidéo, nécessaire pour OpenCV
}
class eye { //classe pour chaque paire de yeux
float x; //positionnement de la paire sur l'écran sur x
float y;//positionnement de la paire sur l'écran sur y
float mx;//positionnement du visage sur l'écran sur x
float my;//positionnement du visage sur l'écran sur y
float langle;
float ldist;
float lx;//valeur vers laquelle la rétine doit se déplacer par rapport au centre pour viser un visage sur x
float ly;//valeur vers laquelle la rétine doit se déplacer par rapport au centre pour viser un visage sur y
boolean shutch;//état de l'oeil; ouvert ou fermé
float shut;//valeur y de l'ellipse qui crée l'oeil
float pupil;//taille de la rétine
eye() {
}
void shut() {
shutch = false; //change l'état de la paire sur fermé
}
void open() {
shutch = true; // change l'état de la paire sur ouvert
}
void opening() {
if (shutch) { //si la paire est ouverte
if (shut<100) { //si sa taille ne dépasse pas 100
shut+=10; //ouvre progressivement la paire
}
} else { // si la paire est fermée
if (shut>0) {// si sa taille est supérieure à 0
shut+=-10; // ferme progressivement la paire
}
if (shut<10) { // si les yeux sont fermés
x = random(200, -200+width); //attribue de nouvelles coordonnées à la paire sur x
y = random(200, -200+height); //attribue de nouvelles coordonnées à la paire sur y
}
}
}
void update() {
langle = atan2(mx-x, my-y); //calcule l'angle vers lequel la rétine doit s'orienter
ldist = dist(mx, my, x, y); //calcule la distance entre la paire et le visage
lx = sin(langle)*ldist/30;
ly = cos(langle)*ldist/30;
}
void set() {
x = random(200, -200+width); //donne des positions aléatoires sur x
y = random(200, -200+height); //donne des positions aléatoires sur y
}
void display() {
noStroke(); //pas de contours
fill(255); //remplir en blanc
ellipse(x-100, y, 100, shut); //premier globe blanc décalé sur la gauche
ellipse(x+100, y, 100, shut); //deuxième globe blanc décalé sur la droite
fill(0); //remplir en noir
ellipse(x+lx-100, y+ly, pupil, pupil); //premiere rétine positionnée par rapport
ellipse(x+lx+100, y+ly, pupil, pupil);
if (shutch) { //si l'oeil est ouvert la rétine est à 50
pupil=50;
} else { //sinon si l'oeil est fermé elle est sur 0
if (shut<10) {
pupil = 0;
}
}
}
void debug() { //affiche la position d'un visage
fill(255, 0, 0);
ellipse(mx, my, 50, 50);
}
}
==== ✔ MutiPONG ====
Version jouable ici >>>>>> https://guyomarch.neocities.org//MUTIPONG.html
{{ :wiki:projets:projets:pong.png |}}
/* @pjs preload="MUTI.png"; */
int x;
int y;
int deplacementX;
int deplacementY;
PImage img;
int xp;
int yp;
int xpp;
int ypp;
int score1 = 0;
int score2 = 0;
void setup() {
img = loadImage("MUTI.png");
size(900, 900);
x = 200; // commençons au centre de l'écran
y = 200;
deplacementX = 9;
deplacementY = -3;
xp = 0+50;
xpp = width-50;
noStroke();
fill(0, 0, 0);
}
void draw() {
mouse();
auto();
nettoyer();
bouger();
rebondir();
dessiner();
image(img, x-50, y-50);
fill(255);
rect(xp, yp, 20, 60);
rect(xpp, ypp, 20, 60);
textSize(32);
text((score1), width/2-100, 30);
text((score2), width/2+100, 30);
}
void mouse(){
yp = mouseY;
}
void auto() {
if (yypp+30) {
ypp+=+4;
}
}
void keyPressed() {
if (key == 'q' == true) {
yp= yp+10;
} else if (key == 'a') {
yp= yp-10;
}
if (key == 'm') {
ypp= ypp+10;
} else if (key == 'p') {
ypp= ypp-10;
}
}
void nettoyer() {
fill(0);
rect(0, 0, width, height);
}
void rebondir() {
if ( (x > width-70 && x < width-50 && y>ypp && y 50 && y>yp && y width && deplacementY > 0) || (y < 0 && deplacementY < 0) ) {
deplacementY = -deplacementY;
}
if (x < 0) {
x= height/2;
y=width/2;
score2++;
}
if (x > width) {
x= height/2;
y=width/2;
score1++;
}
}
void bouger() {
x = x + deplacementX;
y = y + deplacementY;
}
void dessiner() {
fill(255);
ellipse(x, y, 20, 20);
}
==== ✔ Cercle qui fait des formes ====
Un cercle qui suit la souris, ça fait de belles formes
{{ :wiki:projets:projets:sans-titre-5.gif |}}
float t;
float t2;
float CELL_SIZE = 50;
float a;
float b;
void setup() {
fullScreen();
background(0);
}
void draw() {
//translate(width/2, height/2);
t+=0.01;
t2+=0.001;
noStroke();
fill(0, 50);
rect(0, 0, width, height);
pushMatrix();
translate(width/2, height/2);
//scale(2,2);
//rotate(t);
for (float y = 0; y<2400; y+=CELL_SIZE) {
PVector p = new PVector(x1(t+y), (y1(t+y)));
for (int i = 0; i<200; i++) {
float oldX = p.x;
float oldY = p.y;
float angle = noise(p.x /200, p.y /200 )*PI*(mouseX/100);
//float angle = noise(x1(t+y)/p.x/200,(y1(t+y))/p.y/200)*PI*10;
float vx = cos(angle)*mouseY/100;
float vy = sin(angle)*mouseY/100;
p.x+=vx;
p.y+=vy;
strokeWeight(0.01);
stroke(255);
stroke(x1(t+y),y1(t+y),-x1(t+y)+-y1(t+y));
line(oldX, oldY, p.x, p.y);
}
}
noStroke();
fill(0);
//ellipse(0, 0, 300, 300);
popMatrix();
}
float x1(float t) {
return cos(t/2)*300;
}
float y1(float t) {
return sin(t/2)*300;
}
==== ✔ Et encore ====
Pareil, c'est joli
{{ :wiki:projets:projets:sans-titre-4.gif |}}
color c;
float a;
int b;
int d;
int aa =1;
int bb=2;
int dd=3;
float r;
float s=60;
int ss=1;
void setup() {
fullScreen();
background(0);
}
void draw() {
pushMatrix();
translate(width/2, height/2);
rotate(r+=0.01);
scale(s/100);
for (int i = -width; i 255 || a < 0) {
aa=-aa;
}
if (b>255 || b < 0) {
bb=-bb;
}
if (d>255 || d < 0) {
dd=-dd;
}
if (s>100 || s<60) {
ss=-ss;
}
popMatrix();
}
==== ✔ Parametric ====
Un code utile pour comprendre la fonction retour
{{ :wiki:projets:projets:para.gif |}}
float t;
int NUM_LINES = 20;
void setup() {
size(1000, 1000);
background(20);
}
void draw() {
background(20, 20, 20);
stroke(200, 200, 200);
strokeWeight(1);
translate(width/2, height/2);
scale(3, 3);
for (int i = 0; i < NUM_LINES; i++) {
PVector p = new PVector(x1(t+i), y1(t+i));
PVector p2 = new PVector(x2(t+i), y2(t+i));
float oldX = p.x;
float oldY = p.y;
float angle = noise(p.x /200 + t, p.y /200)*PI*2;
float vx = cos(angle)*20;
float vy = sin(angle)*15;
p.x+=vx;
p.y+=vy;
line(oldX, oldY,p2.x,p2.y);
}
t++;
}
float x1(float t) {
return cos(t/10)*50;
}
float y1(float t) {
return sin(t/10)*60+sin(t/20)*40;
}
float x2(float t) {
return cos(t/20)*70;
}
float y2(float t) {
return sin(t/10)*40+sin(t/5)*15;
}
Sources:
https://www.openprocessing.org/sketch/622355 utilisation des lignes de code pour le calcul du déplacement de la rétine.
https://www.youtube.com/watch?v=LaarVR1AOvs&t=555s utilisation de la fonction retour.
https://www.youtube.com/watch?v=DuhH6s-afNQ&t=27s utilisation du noise.