processing : variable de class (page 3/3)

cgiles · 2012-01-25 21:14:12

Repart du code que j'avais posté sur la page précédente, c'est ce que j'ai fait pour avoir une base fonctionnel.

Ars Robota · 2012-01-25 21:17:41

Merci beaucoup de ton aide (et de ta patience!), je vois ça tout de suite.

Edit: OK, au temps pour moi je n'avais pas ajouté ton code dans le bon sketch ().
J'ai effectivement deux tendrils dont un avec un émetteur de pollen qui colle à ce que je cherche. Je vais nettoyer le code et décortiquer tout ça et je te ferais part de mes modifs perso.

Encore merci à toi et à turboconnard pour votre aide!

aR

Dernière modification par Ars Robota (2012-01-25 21:25:16)

Ars Robota · 2012-01-25 22:33:11

Alors je reviens avec mon code modifié. Le voici:

PollenManager pollenManager;// PollenManager appelera Tendril et Pollen
float ang = 0;
// CGILES : incrémenteur pour le noise
float j=random(0,1000);
float nValX, nValY, nScale=0.05, m=0.00, n=1.00;

void setup() {
  size(400, 400);
  frameRate(30);
  smooth();
  pollenManager=new PollenManager();
}

void draw() {
  background(255);
  pollenManager.update();
  pollenManager.display();
  //CGILES : au lieu d'utiliser un random , utilisation d'un noise
  //CGILES: le noise est aléatoire mais lisse : http://en.wikipedia.org/wiki/Perlin_noise
  ang += map(noise(j/50),0,1,-10,10);
  j++;
}
/* ****************************** */
class Tendril {
  public PVector posT;
  float col = 0;
  float sat=0;
  float brite=0;
  float aleph=255;
  float s=2;

  Tendril(float _x, float _y) {//déclaration du PVector de position de Tendril
    posT = new PVector(_x, _y);
  }

  void update(float ang) {
    posT.set(posT.x + 3 * cos(radians(ang)), posT.y + 3 * sin(radians(ang)), 0);
    //s+=0.5*random(-1,3);
    s+=0.5;
    sat+=3;
    brite+=1;
  }

  void ink() {
    colorMode(HSB);
    fill(col, sat, brite, aleph);
    noStroke();
    ellipse(posT.x, posT.y, s, s);
    //aleph-=2;
    aleph-=random(1,4);
  }
}
/* ************************************************ */
class Pollen {
  PVector posP;
  float evapo=0;

  Pollen(float _x, float _y) {
    posP=new PVector(_x, _y);
  }
  //CGILES: nouveau instancieurs de classe, prenant directement un objet Trendil en paramètre
  Pollen(Tendril lastTrendil) {//instance d'objet Tendril avec pour nom lastTendril
    posP=new PVector(lastTrendil.posT.x, lastTrendil.posT.y);
  }

  void update(float ang) {
    posP.set(posP.x + 3 * cos(radians(ang)), posP.y + 3 * sin(radians(ang))-evapo, 0);
    evapo+=0.04;
  }
  
  void update2(float nValX, float nValY) {
    posP.set(posP.x + nValX, posP.y + nValY);
  }

  void ink() {
    noFill();
    stroke(0, 255, 0);
    ellipse(posP.x, posP.y, 8, 8);
  }
}
/* ****************************************************************** */
class PollenManager {
  //CGILES: typage des arraylist en java 1.5, super pratique
  //CGILES: l'arraylist renverra directement des objet selon le type demandé
  //CGILES: ci dessus une arraylist Pollen et une arraylist Tendril
  ArrayList<Pollen> pollens;
  ArrayList<Tendril> tendrils;
  float ang;
  int k;

  PollenManager() {
    tendrils = new ArrayList();
    pollens=new ArrayList();
    ang=0;
    k=(int)random(0, 1000);
  }

  void update() {
    ang += map(noise(k/50), 0, 1, -10, 10);
    k++;
    tendrils.add( new Tendril(width / 2, height / 2));
    //CGILES:retrait de la création de lastTrendril), car l'arraylist est typée
  /* CGILES : utilisation du nouveau créateur d'instance, 
  et on prend les valeur x et y du premier tendril 
  pour les mettre dans  le dernier element de la liste pollens*/
    pollens.add(new Pollen(tendrils.get(0)));//ajouter un élément pollens

    if (tendrils.size() > 100) {//si on dépasse le nombre d'élément tendrils
      tendrils.remove(0);//on enlève le premier élément tendrils
    }
    if (pollens.size()>100) {
      pollens.remove(0);
    }

    for (int i = 0; i < tendrils.size(); i++) {
      tendrils.get(i).update(ang);
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(i).update(ang);
    }
  }
  
  void update2() {
    for (int j=0;j<pollens.size()-1;j++) {
      nValX=noise((n+x[j])*nScale);
      nValY=noise((m+j)*nScale);
      pollens.get(j).update2(nValX, nValY);
    }
  }
  
  void  display() {
    for (int i = 0; i < tendrils.size(); i++) {
      tendrils.get(i).ink();
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(i).ink();
    }
  }
}

Maintenant j'ai deux questions/problèmes:
- quelle est la cause du message d'erreur relatif au nombre de paramètre dans update2?
- comment sélectionner la première instance de l'arraylist pollens (dans pollens.get)?

Merci beaucoup,

aR

cgiles · 2012-01-26 07:35:54

Si c'est update si :
void update2() {
for (int j=0;j<pollens.size()-1;j++) {
nValX=noise((n+x[j])*nScale);
nValY=noise((m+j)*nScale);
pollens.get(j).update2(nValX, nValY);
}
}
je vois aucune liste nommé "x"
si c'est celui la :
void update2(float nValX, float nValY) {
posP.set(posP.x + nValX, posP.y + nValY,0);
}
c'est le fait qu'il manque un zero a la fin pour les z.

Pour avoir accès a ton premier membre, sois tu testes avec un if si i=0 dans un boucle, sinon hors boucle tu fais un pollens.get(0);

Ars Robota · 2012-01-26 22:17:53

citation :
si c'est celui la :
void update2(float nValX, float nValY) {
posP.set(posP.x + nValX, posP.y + nValY,0);
}
c'est le fait qu'il manque un zero a la fin pour les z

Exact, j'avais oublié ce petit zéro, merci de me le rappeler... Mais tu as également pointé le problème de ma liste x manquante.

Celle-ci vient d'un autre sketch que je voudrais mélanger avec le sketch présent. Initialement il s'agit d'une liste déclarée sous la forme float[] x=new float[nbr];
Je vais essayer de l'insérer en gardant cette forme là.

Merci,
aR

cgiles · 2012-01-27 10:06:24

Je te conseille fortement de ne pas utiliser de x ou y comme nom de variable, déja parce que processing s'en sert je crois, ensuite pour la lecture de ton code^^ mais xList posListX, ect...

Ars Robota · 2012-01-27 19:45:12

Merci du conseil, je corrige ça!
Je me suis rendu compte que j'avais oublié d'appeler ma fonction update2 dans draw()... Corrigé aussi.
A présent le résultat semble un peu plus "logique" mais je pense que je devrais déplacer ma boucle for dans la fonction update2 de Pollen...

PollenManager pollenManager;// PollenManager appelera Tendril et Pollen
float ang = 0;
// CGILES : incrémenteur pour le noise
float j=random(0,1000);
int nbr=50;// nombre d'instances de Pollen

void setup() {
  size(400, 400);
  frameRate(30);
  smooth();
  pollenManager=new PollenManager();
}

void draw() {
  background(255);
  pollenManager.update();
  pollenManager.update2();
  pollenManager.display();
  //CGILES : au lieu d'utiliser un random , utilisation d'un noise
  //CGILES: le noise est aléatoire mais lisse : http://en.wikipedia.org/wiki/Perlin_noise
}
/* ****************************** */
class Tendril {
  public PVector posT;
  float col = 0;
  float sat=0;
  float brite=0;
  float aleph=255;
  float s=2;

  Tendril(float _x, float _y) {//déclaration du PVector de position de Tendril
    posT = new PVector(_x, _y);
  }

  void update(float ang) {
    posT.set(posT.x + 3 * cos(radians(ang)), posT.y + 3 * sin(radians(ang)), 0);
    //s+=0.5*random(-1,3);
    s+=0.5;
    sat+=3;
    brite+=1;
  }

  void ink() {
    colorMode(HSB);
    fill(col, sat, brite, aleph);
    noStroke();
    ellipse(posT.x, posT.y, s, s);
    aleph-=2;
    //aleph-=random(1,4);
  }
}
/* ************************************************ */
class Pollen {
  PVector posP;
  float evapo=0;
  float ease=0;

  Pollen(float _x, float _y) {
    posP=new PVector(_x, _y);
  }
  //CGILES: nouveau instancieurs de classe, prenant directement un objet Trendil en paramètre
  Pollen(Tendril lastTrendil) {//instance d'objet Tendril avec pour nom lastTendril
    posP=new PVector(lastTrendil.posT.x, lastTrendil.posT.y);
  }

  void update(float ang) {
    posP.set(posP.x + 3 * cos(radians(ang)), posP.y + 3 * sin(radians(ang))-evapo, 0);
    evapo+=0.04;
  }
  
  void update2(float nValX, float nValY) {
    for (int i=0;i<nbr;i++) {
      posP.set(posP.x+(nValX*ease), posP.y-(nValY*ease), 0);
      evapo+=0.04;
    }
    ease+=0.01;
  }

  void ink() {
    noFill();
    stroke(0, 255, 0);
    ellipse(posP.x, posP.y, 8, 8);
  }
}
/* ****************************************************************** */
class PollenManager {
  //CGILES: typage des arraylist en java 1.5, super pratique
  //CGILES: l'arraylist renverra directement des objet selon le type demandé
  //CGILES: ci dessus une arraylist Pollen et une arraylist Tendril
  ArrayList<Pollen> pollens;
  ArrayList<Tendril> tendrils;
  float ang;// pour le calcul de position de Tendril
  int k;// pour le calcul de ang
  float[] xList=new float[nbr];// liste de x pour les instances de Pollen (sauf la première)
  float nValX, nValY, nScale=0.05, m=0.00, n=1.00;

  PollenManager() {
    tendrils = new ArrayList();
    pollens=new ArrayList();
    ang=0;
    k=(int)random(0, 1000);
    for(int i=0;i<nbr;i++) {
      xList[i]=random(-100, 100);
    }
  }

  void update() {
    ang += map(noise(k/50), 0, 1, -10, 10);
    k++;
    tendrils.add( new Tendril(width / 2, height / 2));
    //CGILES:retrait de la création de lastTrendril), car l'arraylist est typée
  /* CGILES : utilisation du nouveau créateur d'instance, 
  et on prend les valeur x et y du premier tendril 
  pour les mettre dans  le dernier element de la liste pollens*/
    pollens.add(new Pollen(tendrils.get(0)));//ajouter un élément pollens

    if (tendrils.size() > 100) {//si on dépasse le nombre d'élément tendrils
      tendrils.remove(0);//on enlève le premier élément tendrils
    }
    if (pollens.size()>nbr) {
      pollens.remove(0);
    }

    for (int i=0;i<tendrils.size();i++) {
      tendrils.get(i).update(ang);
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(0).update(ang);
    }
  }
  
  void update2() {
    for (int j=1;j<pollens.size()-1;j++) {// déplacer cette boucle dans update2 de Pollen
      nValX=noise((n+xList[j])*nScale);
      nValY=noise((m+j)*nScale);
      pollens.get(j).update2(nValX, nValY);
    }
    m+=0.08;
    n=m+0.01;
  }
  
  void  display() {
    for (int i = 0; i < tendrils.size(); i++) {
      tendrils.get(i).ink();
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(i).ink();
    }
  }
}

Pendant le premier tour de boucle draw tout va bien, mais rapidement les instances de Pollens cessent de suivre les coordonnées issues de noise pour ne suivre que le trajet de Tendril... J'ai dû commettre une erreur au niveau de la fonction update de PollenManager, quelqu'un aurait-il une idée?

Dernière modification par Ars Robota (2012-02-08 18:29:31)

Ars Robota · 2012-02-08 18:30:12

up?

Ars Robota · 2012-02-08 18:56:04

Yahou! J'ai trouvé: il suffisait de copier la ligne

xList[i]=random(-100, 100);

depuis le constructeur de PollenManager vers la fonction update2 du même PollenManager. Seul petit soucis à régler: les instances de Pollen partent inévitablement vers la droite, ce qui est logique puisque j'ai dans update2 de Pollen posP.set(posP.x+(nValX*ease), posP.y-(nValY*ease), 0).

Malheureusement je dois être désespérément trop con pour comprendre le fonctionnement de la fonction noise(), donc je fais plus du bricolage qu'autre chose...

Voici le code complet (qui mérite certainement d'être nettoyé...)

PollenManager pollenManager;// PollenManager appelera Tendril et Pollen
float ang = 0;
// CGILES : incrémenteur pour le noise
float j=random(0,1000);
int nbr=50;// nombre d'instances de Pollen

void setup() {
  size(400, 400);
  frameRate(30);
  smooth();
  pollenManager=new PollenManager();
}

void draw() {
  background(255);
  pollenManager.update();
  pollenManager.update2();
  pollenManager.display();
  //CGILES : au lieu d'utiliser un random , utilisation d'un noise
  //CGILES: le noise est aléatoire mais lisse : http://en.wikipedia.org/wiki/Perlin_noise
}
/* ****************************** */
class Tendril {
  public PVector posT;
  float col = 0;
  float sat=0;
  float brite=0;
  float aleph=255;
  float s=2;

  Tendril(float _x, float _y) {//déclaration du PVector de position de Tendril
    posT = new PVector(_x, _y);
  }

  void update(float ang) {
    posT.set(posT.x + 3 * cos(radians(ang)), posT.y + 3 * sin(radians(ang)), 0);
    //s+=0.5*random(-1,3);
    s+=0.5;
    sat+=3;
    brite+=1;
  }

  void ink() {
    colorMode(HSB);
    fill(col, sat, brite, aleph);
    noStroke();
    ellipse(posT.x, posT.y, s, s);
    aleph-=2;
    //aleph-=random(1,4);
  }
}
/* ************************************************ */
class Pollen {
  PVector posP;
  float evapo=0;
  float ease=0;

  Pollen(float _x, float _y) {
    posP=new PVector(_x, _y);
  }
  //CGILES: nouveau instancieurs de classe, prenant directement un objet Trendil en paramètre
  Pollen(Tendril lastTrendil) {//instance d'objet Tendril avec pour nom lastTendril
    posP=new PVector(lastTrendil.posT.x, lastTrendil.posT.y);
  }

  void update(float ang) {
    posP.set(posP.x + 3 * cos(radians(ang)), posP.y + 3 * sin(radians(ang))-evapo, 0);
    evapo+=0.04;
  }
  
  void update2(float nValX, float nValY) {
    for (int i=0;i<nbr;i++) {
      posP.set(posP.x+(nValX*ease), posP.y-(nValY*ease), 0);
      evapo+=0.04;
    }
    ease+=0.01;
  }

  void ink() {
    noFill();
    stroke(0, 255, 0);
    ellipse(posP.x, posP.y, 8, 8);
  }
}
/* ****************************************************************** */
class PollenManager {
  //CGILES: typage des arraylist en java 1.5, super pratique
  //CGILES: l'arraylist renverra directement des objet selon le type demandé
  //CGILES: ci dessus une arraylist Pollen et une arraylist Tendril
  ArrayList<Pollen> pollens;
  ArrayList<Tendril> tendrils;
  float ang;// pour le calcul de position de Tendril
  int k;// pour le calcul de ang
  float[] xList=new float[nbr];// liste de x pour les instances de Pollen (sauf la première)
  float nValX, nValY, nScale=0.05, m=0.00, n=1.00;

  PollenManager() {
    tendrils = new ArrayList();
    pollens=new ArrayList();
    ang=0;
    k=(int)random(0, 1000);
    for(int i=0;i<nbr;i++) {
      xList[i]=random(-100, 100);
    }
  }

  void update() {
    ang += map(noise(k/50), 0, 1, -10, 10);
    k++;
    tendrils.add( new Tendril(width / 2, height / 2));
    //CGILES:retrait de la création de lastTrendril), car l'arraylist est typée
  /* CGILES : utilisation du nouveau créateur d'instance, 
  et on prend les valeur x et y du premier tendril 
  pour les mettre dans  le dernier element de la liste pollens*/
    pollens.add(new Pollen(tendrils.get(0)));//ajouter un élément pollens

    if (tendrils.size() > 100) {//si on dépasse le nombre d'élément tendrils
      tendrils.remove(0);//on enlève le premier élément tendrils
    }
    if (pollens.size()>nbr) {
      pollens.remove(0);
    }

    for (int i=0;i<tendrils.size();i++) {
      tendrils.get(i).update(ang);
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(0).update(ang);
    }
  }
  
  void update2() {
    for (int j=1;j<pollens.size()-1;j++) {// déplacer cette boucle dans update2 de Pollen
      xList[j]=random(-100, 100);
      nValX=noise((n+xList[j])*nScale);
      nValY=noise((m+j)*nScale);
      pollens.get(j).update2(nValX, nValY);
    }
    m+=0.08;
    n=m+0.01;
  }
  
  void  display() {
    for (int i = 0; i < tendrils.size(); i++) {
      tendrils.get(i).ink();
    }
    for (int i=0;i<pollens.size();i++) {
      pollens.get(i).ink();
    }
  }
}

Annonce

#31 2012-01-25 21:14:12 Re : variable de class

Re: variable de class

#32 2012-01-25 21:17:41 Re : variable de class

Re: variable de class

#33 2012-01-25 22:33:11 Re : variable de class

Re: variable de class

#34 2012-01-26 07:35:54 Re : variable de class

Re: variable de class

#35 2012-01-26 22:17:53 Re : variable de class

Re: variable de class

citation :

#36 2012-01-27 10:06:24 Re : variable de class

Re: variable de class

#37 2012-01-27 19:45:12 Re : variable de class

Re: variable de class

#38 2012-02-08 18:30:12 Re : variable de class

Re: variable de class

#39 2012-02-08 18:56:04 Re : variable de class

Re: variable de class

Pied de page des forums