Outils pour utilisateurs

Outils du site


wiki:projets:light-painting:accueil

Light painting processing

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

Description

Grand fan de graffiti, je me suis rapidement heurté à certaines problématiques de cette discipline artistico-sportive. En effet, cette pratique pose quelques problèmes en terme de support et d'outil. Souvent en nombre limité dans nos villes (sur-fréquentés) ou illégaux, les murs posent un réel problème. De plus, les aérosols, perches, rouleaux, sous-couches sont très expansifs pour les plus honnêtes d'entre nous. En d'autres termes, il n'est pas aisé de faire de la ville son territoire d’expérimentation, son cahier de brouillon. Cependant, une sous-catégorie de graffiti permet de solutionner ces problèmes: Le light painting. C'est un des courants les plus sage de ce mouvement puisqu'il ne laisse que peu de trace après passage. Bien que cela offre une certaine liberté et soit très attrayant pour le grand public, quelques inconvénients demeurent. 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 ses contraintes (l'appareil photo/pied/…). L'idée est d'obtenir un outil qui puisse générer une certaines non-maîtrise, de petits accidents générés par les limites du programme(zone travail incertaine webcam, effet miroir, légère pixellisation, débordement lumineux…) afin d'enrichir un répertoire de forme (typographique principalement).

Outil de dessin dans sa forme la plus basique

Codes

Light tracking

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

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

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

    Capture cam;                                                                                              //Nom de la classe 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 le ballayage s'arrête
             theBrightPixel = i;                                                                                        //Le pixel brillant est 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
     } 
     

Light Painting

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

fichiers processing

Production

{{:wiki:projets:light-painting:light-painting:abcedaire.pdf|

Références/ressources

wiki/projets/light-painting/accueil.txt · Dernière modification: 2018/05/15 14:58 (modification externe)