TONER KEBAB WIKI

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Coopération Humains-Machines / Humain-Humain ======
===== Codes des prototypes =====

  * Porteur du projet : Thomas Leloup
  * Date : 20/02/2018
  * Contexte : Mémoire DSAA
  * Lien : http://thomasleloup.fr/

===== Handtracking =====

==== Code principal ====
<code>
import kinect4WinSDK.*; //importer bibliothèque Kinect pour windows SDK
import KinectPV2.KJoint; //importer bibliothèque KinectPV2.KJoint
import KinectPV2.*; //importer bibliothèque KinectPV2
KinectPV2 kinect; //créer un attribut KinectPV2 nommé kinect
//attribut couleur en dégradé 1
int r = 255;
int g = 0;
int b = 0;
//boîte de particules de la classe Particle
ArrayList<Particle> allParticles = new ArrayList<Particle>();
float currentHue = 0; //teinte actuelle = 0
ParticleSystem ps; //attribut nommé ps de la classe ParticleSystem
PVector target; //vecteur nommé target
PVector[] points; //boîte de vecteurs nommé points
float x, y, angle, ease = 0.5; //introduire x, y, angle et ease = 0.5
boolean easing = true; //booléen nommé easing en vrai
//num => nombre de particules (cercles) lors du tracking
//frames => nombre d’images
int num=70, frames=165;
PImage main; //créer une image nommé main
PImage main1; //créer une image nommé main1
void setup() {
fullScreen(P3D); //affichage plein écran de la zone de travail (zone en 3D)
frameRate(30); //nombre d’images par seconde
//l’attribut nommé kinect devient une zone de capture de la Kinect
kinect = new KinectPV2(this);
kinect.enableSkeletonColorMap(true); //autorisation détection du squelette
kinect.enableColorImg(true); //autorisation de la colorisation de l’image de la kinect
kinect.init(); //démarrage de la kinect
main = loadImage(«main.png»); // l’image main télécharge le fichier main.png
main1 = loadImage(«main1.png»); // l’image main1 télécharge le fichier main1.png
//ps
ps = new ParticleSystem(new PVector(width/2, 50));
background(255); //fond blanc sur la zone de travail
points = new PVector[num];
for (int i=0; i<num; i++) {
points[i] = new PVector(width/2, height/2);
}
}

void draw() {
background(0); //fond noir sur la zone de travail
fill(255); //remplir en blanc pour toutes formes situées à la suite
textSize(80); //corps du texte en px
textAlign(CENTER); //alignement de tecte centré
text(«Approchez-vous !»,width/2,height/2-100); //texte au coordonnées indiquées derrière
text(«Et placez-votre main gauche en avant !»,width/2,height/2+20); //texte au coordonnées
indiquées derrière
imageMode(CENTER); //mode d’image centré
main1.resize(0,300); //redimension de l’image main1 (300px)
tint(255); //teinture blanche pour toutes formes situées à la suite
image(main1,width/2,height/2+280); //insérer image nommé main1
translate(-200,0); //déplacer de -200 sur x et 0 sur y
scale(1.8,1.6); //redimensionnement de la capture qui suit
//boîte qui comprend le squelette de détection du corps
ArrayList<KSkeleton> skeletonArray = kinect.getSkeletonColorMap();
//pour toutes jointures comprises dans la boîte de valeurs du squelette
for (int i = 0; i < skeletonArray.size(); i++) {
//skeleton de classe KSkeleton prend toutes valeurs i de la boîte du squelette
KSkeleton skeleton = (KSkeleton) skeletonArray.get(i);
if (skeleton.isTracked()) { //si il y a tracking du squelette
//chaque jointures de classe KJoint prends les jointures du squelette
KJoint[] joints = skeleton.getJoints();
background(0); //fond noir sur la zone de travail
//nouvelle couleur nommé col prend les couleurs indexées du squelette
color col = skeleton.getIndexColor();
fill(col); //remplir avec la couleur col
stroke(col); //contours avec la couleur col
//détection seulement de la main gauche
drawHandState(joints[KinectPV2.JointType_HandLeft]);
}
}
}
//lorsqu’il y a tracking de la main gauche
void drawHandState(KJoint joint) {
noStroke(); //pas de contours
pushMatrix(); //début zone restreinte
tint(r,b,g); //teinture par r,g,b
imageMode(CENTER); //mode image centré
main.resize(0,80); //redimension image main (80px)
//image main aux coordonnées de la position de la main gauche
image(main,joint.getX(), joint.getY());
popMatrix(); //fin zone restreinte
//ajout de particules ps aux coordonnées de la position de la main gauche
ps.addParticle(joint.getX(), joint.getY());
//fonctionnement et actualisation des particules ps
ps.run();

programme de transition des couleurs r,g,b
if(g < 255 && b == 0)
{
g = g + 5;
}
//Yellow to green
if (g == 255 && b == 0)
{
if(r >= 0)
{
r = r - 5;
}
}
//Green to cyan
if (r == 0 && g == 255)
{
if(b < 255)
{
b = b + 5;
}
}
//cyan to blue
if (b == 255 && r == 0)
{
if(g > 0)
{
g = g - 5;
}
}
//Purple to magenta
if (b == 255 && g == 0)
{
if(r < 255)
{
r = r + 5;
}
}
//magenta to red
if(r == 255 && g == 0)
{
if(b > 0)
{
b = b - 5;
}
}
}
</code>
\\




==== Classe Système de Particule ====
<code>
class Particle {
//création attributs des particules
PVector location; //positions
PVector location1;
PVector location2;
PVector location3;
PVector velocity; //vitesse de déplacement des particules
PVector acceleration; //accélération de leur vitesse
float lifespan;
Particle(float x, float y) {
acceleration = new PVector(0, 0.05);
//random => valeur aléatoire entre deux chiffres
velocity = new PVector(random(-1, 1), random(-2, 0));
location = new PVector(x, y);
location1 = new PVector(x+random(-10, 8), y+random(-8, 30));
location2 = new PVector(x+random(-30, 5), y+random(-1, 10));
location3 = new PVector(x+random(-20, 6), y+random(-20, 4));
lifespan = 255.0;
}
//méthode pour afficher les deux autres méthodes
void run() {
update();
display();
}
//Méthode pour mettre à jour la position
void update() {
velocity.add(acceleration);
location.add(velocity);
lifespan -= 3;
}
//Méthode pour lire les particules
void display() {
noStroke();
//stroke(255, lifespan);
fill(r,g,b, 205-lifespan/2);
ellipse(location.x, location.y, 20, 20);
ellipse(location1.x, location1.y, 20, 20);
ellipse(location2.x, location2.y, 20, 20);
ellipse(location3.x, location3.y, 20, 20);
}
//Booléen en fonction de l’opacité des particules (au=dessus)
boolean isDead() {
if (lifespan < 100.0) {
return true;
} else {
return false;
}
}
}
</code>
\\




==== Classe Particule ====
<code>
// Classe pour décrire le groupe de Particules
// Un ArrayList est utilisé pour organiser la liste des Particules
class ParticleSystem {
ArrayList<Particle> particles;
PVector origin;
ParticleSystem(PVector location) {
origin = location.get(); //origin prend les valeurs de location (voir autre classe)
particles = new ArrayList<Particle>(); //ajout de particules dans la boîte
}
//méthode d’ajout de particules sur la zone de travail
void addParticle(float x, float y) {
particles.add(new Particle(x,y));
}
//méthode pour afficher les particules dans la zone de travail
void run() {
for (int i = particles.size()-1; i >= 0; i--) {
Particle p = particles.get(i);
p.run();
if (p.isDead()) { //voir booléen de l’autre classe
particles.remove(i);
}
}
}
}
</code>




\\
\\
\\
\\
----
===== Shake it up =====
==== Code principal ====
<code>
import gab.opencv.*; //importer la bibliothèque opencv
import KinectPV2.*; //importer la bibliothèque Kinect
//attribut couleur en dégradé 1
int r = 255;
int g = 0;
int b = 0;
//attribut couleur en dégradé 2
int r1 = 0;
int g1 = 255;
int b1 = 255;
KinectPV2 kinect; //créer un attribut KinectPV2 nommé kinect
OpenCV opencv; //créer un attribut OpenCV nommé opencv
float polygonFactor = 1; //facteur de résolution du corps
int threshold = 10; //seuil de détection
int maxD = 1800; //Distance max de captation 1.8m
int minD = 50; //Distance min de captation 50cm
boolean contourBodyIndex = false; //booléen pour la détection du contour du corps
void setup() {
size(1920, 1080, P3D); //taille de la zone de travail avec 3D
//l’attribut nommé opencv devient une zone de capture de la bibliothèque opencv
opencv = new OpenCV(this, 512, 424);
//l’attribut nommé kinect devient une zone de capture de la Kinect
kinect = new KinectPV2(this);
kinect.enableDepthImg(true); //autorisation profondeur de l’image kinect
kinect.enableBodyTrackImg(true); //autorisation du tracking du corps
kinect.enablePointCloud(true); //autorisation d’un nuage de point de l’image kinect
kinect.init(); //démarrage de la kinect
}
void draw() {
//remplir avec les valeurs de couleurs r,g,b définies auparavant (opacité réduite : 10) pour toutes
formes situées à la suite
fill(r,g,b,10);
rect(0,0,width,height); //rectangle de la taille de zone de travail
noFill(); //pas de remplissage pour toutes formes situées à la suite
strokeWeight(1);//taille des contours 1px
scale(3.75,2.45,5);//redimensionnement de la capture qui suit
if (contourBodyIndex) { //si il détecte un corps
opencv.loadImage(kinect.getBodyTrackImage()); //alors chargement de l’image du tracking de
la kinect
//PImage dst = opencv.getOutput();
} else { //sinon
opencv.loadImage(kinect.getPointCloudDepthImage()); //chargement de l’image de profondeur
de la kinect
//PImage dst = opencv.getOutput();
}
//tableau qui utilise la classe Contour de la bibliothèque où contours prend les valeurs de détection
de contours de opencv
ArrayList<Contour> contours = opencv.findContours(false, false);
if (contours.size() > 0) { //si la taille de countours est supérieur à 0
for (Contour contour : contours) { //pour tout contour de classe Contour prenant la valeurs de
contours
//faire une approximation de la résolution grâce au facteur de résolution définis au départ (en
haut)
contour.setPolygonApproximationFactor(polygonFactor);
if (contour.numPoints() > 50) { //si le nombre de points de contour dépasse 50
noStroke(); //pas de contours pour toutes formes situées à la suite
beginShape(); //début de forme
//remplir avec les valeurs de couleurs r1,g1,b1 définies auparavant pour toutes formes
situées à la suite
fill(r1,g1,b1);
//pour tout point prenant les valeurs d’approximation définies par contour
for (PVector point : contour.getPolygonApproximation ().getPoints()) {
vertex(point.x, point.y); //faire des sommets avec comme coordonnées chaque pixel capté
dans la zone de captation
}
endShape(); //fin de forme
}
}
//programme de transition des couleurs r,g,b
if(g < 255 && b == 0)
{
g = g + 5;
}
//Yellow to green
if (g == 255 && b == 0)
{
if(r >= 0)
{
r = r - 5;
}
}
//Green to cyan
if (r == 0 && g == 255)
{
if(b < 255)
{
b = b + 5;
}
}
//cyan to blue
if (b == 255 && r == 0)
{
if(g > 0)
{
g = g - 5;
}
}
//Purple to magenta
if (b == 255 && g == 0)
{
if(r < 255)
{
r = r + 5;
}
}
//magenta to red
if(r == 255 && g == 0)
{
if(b > 0)
{
b = b - 5;
}
}
//programme de transition des couleurs r1,g1,b1
if(g1 < 255 && b1 == 0)
{
g1 = g1 + 5;
}
//Yellow to green
if (g1 == 255 && b1 == 0)
{
if(r1 >= 0)
{
r1 = r1 - 5;
}
}
//Green to cyan
if (r1 == 0 && g1 == 255)
{
if(b1 < 255)
{
b1 = b1 + 5;
}
}
//cyan to blue
if (b1 == 255 && r1 == 0)
{
if(g1 > 0)
{
g1 = g1 - 5;
}
}
//Purple to magenta
if (b1 == 255 && g1 == 0)
{
if(r1 < 255)
{
r1 = r1 + 5;
}
}
//magenta to red
if(r1 == 255 && g1 == 0)
{
if(b1 > 0)
{
b1 = b1 - 5;
}
}
}
kinect.setLowThresholdPC(minD); //faire un seuil minimale pour la distance minimale de captation
kinect.setHighThresholdPC(maxD); //faire un seuil maximale pour la distance maximale de
captation
}
</code>
TONER KEBAB WIKI

Outils pour utilisateurs

Outils du site

Outils de la page
