• fullscreen
  • Dufresne_TP2_tapisserie.pde
  • /************************************
    Evelyne Dufresne
    EDM4600-50
    TP2-Tapisserie
    
    2011-02-25
    *************************************/
    
    // Déclaration des variables
    PVector vRandomTemp,vRandomTemp2; // vecteurs temporaire
    PVector vRandom1,vRandom2,vRandom3,vRandom4; // vecteurs random 
    PVector vPt0Pt1,vPt0Pt2,vPt0Pt3,vPt0Pt4;// vecteur reliant les points voisins au point central
    float x1,x2,x3,x4;//coordonées en X des points entourant x0
    float y1,y2,y3,y4;//coordonées en Y des points entourant y0
    float prodScalaire01,prodScalaire02,prodScalaire03,prodScalaire04;// Produit scalaire de chaque points
    float fR1, fR2, fX0; // variables sevant à effectuer l'interpolation au point X0
    
    PImage textureUtilise;//texture courante
    PImage[] imgTAB = new PImage[6];//tableau contenant l'ensemble des images
    
    void setup()
    {
      size(300,300,P3D); // Dimensions de la fenêtre
      smooth();
      
      //Loader les images dans le tableau
      imgTAB[0] = loadImage("texture01.jpg");
      imgTAB[1] = loadImage("texture02.jpg");
      imgTAB[2] = loadImage("texture03.jpg");
      imgTAB[3] = loadImage("texture04.jpg");
      imgTAB[4] = loadImage("texture05.jpg");
      imgTAB[5] = loadImage("texture06.jpg");
      
      textureUtilise = imgTAB[0]; //Texture attribuée par défaut
     
    }
    
    void draw()
    {
      // Texture a appliquer
        keyPressed();
    
    //Afficher chaque point du Canevas  
      for(int i=0; i<300; i++)
      {
        for(int j=0; j<300; j++)
        {
         // calcul de la valeur du bruit au point i,j
         fX0 = valeurBruit(i,j,mouseX,mouseY);
         
         //Affichage du point
         color cx = textureUtilise.get(floor((i+random(0.65,1)*mouseX)%400),floor((j+random(0.65,1)*mouseY)%400));//Trouver la couleur d'un pixel dans la région de la souris
         
         float facteur=100;
         stroke(red(cx)+floor(facteur*fX0),green(cx)+floor(facteur*fX0),blue(cx)+floor(facteur*fX0));//couleur donnée au pixel en considérant la texture et le bruit calculé en ce point
         point(i,j,floor(random(20)));//dessiner le point. La valeur en Z permet des transitions plus douces entre les textures.
      
        }
      }
    }
    
    /*------------------------------------------------------------
    Fonction retournant un vecteur quelconque pour un point donné
    --------------------------------------------------------------*/
    PVector vecteurRandom(float x1, float y1, float x2, float y2)
    {
      float rand2= random(150);
     //Générer un point quelconque aux alentours de la souris
      float PtRandomX = random(x2-rand2,x2+rand2);
      float PtRandomY = random(y2-rand2,y2+rand2);
      float vLongueur;
      
      //Calcul de la longueur du vecteur
      vLongueur = sqrt(pow(PtRandomX - x1,2)+pow(PtRandomY - y1,2));
      
     //Calcul du vecteur normalisé
      vRandomTemp = new PVector((PtRandomX - x1)/vLongueur, (PtRandomY - y1)/vLongueur);
      
      return vRandomTemp;
    }
    
    /*----------------------------------------------------------------
    Fonction retournant un vecteur reliant le voisin au point central
    ------------------------------------------------------------------*/
    PVector vecteurP0(float x1, float y1, float x2, float y2)
    {
      float vLongueur;
      
      //Calcul de la longueur du vecteur
      vLongueur = sqrt(pow(x2 - x1,2)+pow(y2 - y1,2));
      //Calcul du vecteur normalisé
      vRandomTemp2 = new PVector((x2-x1)/vLongueur, (y2-y1)/vLongueur);
      
      return vRandomTemp2;
    }
    
    /*------------------------------------------------------------
        Fonction retournant le produit scalaire de 2 vecteurs
    --------------------------------------------------------------*/
    float prodScalaire(PVector v1, PVector v2)
    {
      float resultat;
      //Calculer le produit scalaire
      resultat= (v1.x * v2.x) + (v1.y * v2.y);
    
      return resultat;
    
    }
    /*-------------------------------------------------------------
            Trouve la valeur du bruit en x0
    ---------------------------------------------------------------*/
    float valeurBruit(int i, int j, int x, int y)
    {
          //définition des coordonnées en X des points entourant x0
          x1=i-1;
          x2=i+1;
          x3=i-1;
          x4=i+1;
          //définition des coordonnées en Y des points entourant y0
          y1=j-1;
          y2=j-1;
          y3=j+1;
          y4=j+1;
         
         //Association d'un vecteur random associé à chaque point 
         vRandom1 = vecteurRandom(x1,y1, x, y);
         vRandom2 = vecteurRandom(x2,y2,  x, y);
         vRandom3 = vecteurRandom(x3,y3,  x, y);
         vRandom4 = vecteurRandom(x4,y4,  x, y);
         
         //Calcul des vecteurs points voisins-point central
         vPt0Pt1 = vecteurP0( i, j, x1, y1);
         vPt0Pt2 = vecteurP0( i, j, x2, y2);
         vPt0Pt3 = vecteurP0( i, j, x3, y3);
         vPt0Pt4 = vecteurP0( i, j, x4, y4);
         
         //Calcul du produit scalaire donnant la valeur du bruit perlin estimé en chaque point.
         prodScalaire01 = prodScalaire(vRandom1, vPt0Pt1);
         prodScalaire02 = prodScalaire(vRandom2, vPt0Pt2);
         prodScalaire03 = prodScalaire(vRandom3, vPt0Pt3);
         prodScalaire04 = prodScalaire(vRandom4, vPt0Pt4);
         
         //Interpolation bilinéaire du bruit perlin au point (x0,y0)
          // estimation inférieure
         fR1 = ((x4-i)/(x4-x3))*prodScalaire03 +((i-x3)/(x4-x3))*prodScalaire04;
         // estimation supérieur
         fR2 = ((x4-i)/(x4-x3))*prodScalaire01 +((i-x3)/(x4-x3))*prodScalaire02;
         //estimation en x0
         fX0 = ((y1-j)/(y1-y3))*fR1+((j-y3)/(y1-y3))*fR2;
         
         return fX0;
    }
    
    /*-----------------------------------------
    Changement d'image en utilisant le clavier
    -------------------------------------------*/
    void keyPressed()
    {
      //Changer de texture en fonction de la touche pesée (Touches 1 à 6 inclusivement.  
      switch(keyCode)
         {
           case(49):
             textureUtilise = imgTAB[0];
             break;
           case(50):
             textureUtilise = imgTAB[1];
             break;
           case(51):
             textureUtilise = imgTAB[2];
             break;
           case(52):
             textureUtilise = imgTAB[3];
             break;
           case(53):
             textureUtilise = imgTAB[4];
             break;   
           case(54):
             textureUtilise = imgTAB[5];
             break;            
       }
    }
    
    

    code

    tweaks (0)

    license

    advertisement

    Evelyne Dufresne

    TP2 - Evelyne Dufresne - tapisserie

    Add to Faves Me Likey@! 1
    You must login/register to add this sketch to your favorites.

    Bruit psoeudo-aléatoire selon la position de la souris.
    Vous pouvez vous changer la texture en pressant les touches 1 à 6 du clavier.

    Sources:
    Comment faire le bruit perlin - Notes de cours IMN528 Université de Sherbrooke - http://pages.usherbrooke.ca/ogodin/resources/imn528/imn528-chap03.pdf - p145 à 157

    interpolation bilinéaire - Notes de cours IMN428 Université de Sherbrooke - http://pages.usherbrooke.ca/ogodin/resources/imn428/imn428-chap03.pdf - p.46

    Suite des sources dans les commentaires (plus de place pour écrire!)

    Evelyne Dufresne
    25 Feb 2011
    Sources (suite):

    Produit scalaire - Notes de cours IMN 428 Université de SHerbrooke - http://pages.usherbrooke.ca/ogodin/resources/imn428/imn428-chap02.pdf - p.10
    You need to login/register to comment.