Porteur(s) du projet : Mehouas Clément
Date : 14/05/2018
Licence : libre !
Contexte : Cours de programmation

Le but est de proposer un support virtuel semblable à une ardoise magique où l'on pourrait expérimenter à loisir ce qui fait les joies du lettrage en light painting (sans les contraintes de l'appareil photo/pied/…). L'idée est d'obtenir un outil qui puisse générer une certaines non-maitrise, de petits accidents afin d'obtenir de nouvelles formes typographiques.

Ici, on se sert de la webcam afin de discriminer le point le plus lumineux dans la captation. Cela sers de base à au code suivant.

/////////////////////////////////////////////////////////////////////////////////////////////////////////Appel aux librairies
   
    import processing.video.*;                                                                              //Librairie video

/////////////////////////////////////////////////////////////////////////////////////////////////////////Déclaration des variables globales

    Capture cam;                                                                                              //Nom de la variable pour la capture de la webcam
    int x,y;                                                                                                  //Déclaration des entiers 

////////////////////////////////////////////////////////////////////////////////////////////////////////Initialisation des variables globales et des paramètres d'affichage
    void setup() {
      
                                                                                                              //Paramètres zone de travail
        size(640,480);                                                                                              //Taille
        frameRate (30);                                                                                             //Nombre image par seconde
        background (0);                                                                                             //Fond noir
      
                                                                                                              // printArray(Capture.list()); (obtenir le nom complet de la webcam)
    
        cam= new Capture(this,640,480,"name=USB Camera,size=640x480,fps=30");                                 //Appeler la webcam/Nom/Dimension/fps
        cam.start();                                                                                          //Démarer la webcam
        }                                                                               
     
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void draw(){
                                                                                                              
    if (cam.available()){                                                                                     //Si la webcam est disponible...                                                                  
        cam.read();                                                                                           //...afficher ce qu'elle capte 
        }  
    
    cam.loadPixels();                                                                                         //Charger l'image pixel par pixel
  
                                                                                                              //Trouver les pixels les plus brillants comparer à un pixel noir
     float maxBri = 0;                                                                                              //Valeur la plus brillante=0
     int theBrightPixel =0;                                                                                         //Le pixel le plus brillant=0(pour le moment)
     for(int i=0; i<cam.pixels.length; i++){                                                                        //Pour i=0, ballayer la zone tant que x est inferieur à i=i+1
         if (brightness(cam.pixels[i])>maxBri){                                                                         //si i plus brillant que 0 (le plus brillant par défaut)...
             maxBri = brightness(cam.pixels[i]);                                                                        //...alors plus brillant***
             theBrightPixel = i;                                                                                        //Le pixel brillant=i
             }
             }
                                                                                                             //Coordonnées du point brillant
     int x = theBrightPixel % cam.width;                                                                            //x=reste la division euclidienne
     int y = floor(theBrightPixel / cam.width);                                                                     //y=quotien de la division euclidienne
  
                                                                                                             //Curseur indiquant le point le plus brillant
     image(cam,0,0);                                                                                                //position du curseur à l'initialisation du programme
     fill(#FF0000,20);                                                                                              //Remplir avec rouge peu opaque
     stroke(255,0,0);                                                                                               //Contour rouge
     ellipse(x,y,20,20);                                                                                            //Forme du curseur
     } 
     

Ici, on modifie le premier programme afin de conserver le tracking du point le plus lumineux et de pouvoir dessiner ainsi sur une surface/fond noir.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Appel aux librairies
     
      import processing.video.*;                                                                                                  //Librairie vidéo
      
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Déclaration des variables globales
     
      Capture cam;                                                                                                                //Nom de la variable pour la capture de la webcam                                                                                                              
      
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Initialisation des variables globales et des paramètres d'affichage
void setup() {
                                                                                                                                 //Paramètres zone de travail
      size(640, 480);                                                                                                                 //Taile de la zone 
      frameRate(30);                                                                                                                  //Nombre d'image par seconde
      background(0);                                                                                                                  //Fond noir
    
                                                                                                                      //printArray(Capture.list()); //obtenir le nom complet de sa webcam pour l'appeler
    
      cam = new Capture(this, 640, 480, "name=USB Camera,size=640x480,fps=30", 30);                                             //Appeler la webcam/Nom/Dimension/fps
      cam.start();                                                                                                              //Démarer la webcam
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void draw() {
    
        if(cam.available()){                                                                                                      //Si la webcam est disponible...   
           cam.read();                                                                                                            //...afficher ce qu'elle capte 
           cam.loadPixels();                                                                                                      //Agir au niveau des pixels de la captation
           loadPixels();                                                                                                          //Même chose qu'au dessus (mais ne fonctionne pas si on le supprime)
           for(int i=0; i<cam.pixels.length; i++) {                                                                               //Pour i=0, ballayage de la zone jusqu'à ce que i=i+1                 
              if(brightness(cam.pixels[i]) > 200) {                                                                                  //Si point brillant supérieur à 200...
                  pixels[i] = color(255);                                                                                             //...Le pixel I est blanc
              }
           }
           updatePixels();
        }
}      
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mouseClicked(){                                                                                                         //Si l'on clique...              
      background(0);                                                                                                                  //...on charge un fond noir par dessus... 
}
 

abcedaire.pdf

Traitement de l'image
Bibliothèque webcam
Alexandra Nolot/Tracking
Tutoriel color tracking Tutoriel light tracking