Salut à tous

voila je souhaite réalisé des dessins qui s'affichent progressivement suivant un balayage simple et aléatoire.
Mon idée première est de faire un tableau à 2 dimensions , quand le système de balayage passe "au dessus" de la coordonnée du dessin, de dire a Processing de changer ce carré qui était blanc en noir (par ex)
Pour le moment j'en suis à l'étape ou j'ai mon tableau et le balayage, je cherche donc des solutions de ce type >
Comment écrire des variables qui seraient les coordonnées ( une variable pour x = 0, y = 1 ) par ex.
déclarer une autre variable pour le processus de balayage, et quand les 2 coïncident > affichage de la bonne couleur de carré.

Bon j'espère ne pas etre trop confu, je post mon code si mon explication n'est pas asse claire

merci pour vos idée

tu peux commencer par utiliser un tableau en deux dimension, c'est le plus simple pour représenter une image.
Ensuite pour ta lecture , si tu veux un affichage progressif, il faut incrémenter image par image verticalement, et lire l'intégrale des données horizontale de la ligne

int[][] grille = {  {0, 1, 1, 0},
                     {1, 0, 0, 1},
                     {1, 0, 0, 1},
                     {0, 1, 1, 0}  };
int i=0;
void setup(){
  size(400,400);
  frameRate(2);
}
void draw(){
for(int j=0;j<4;j++){
if(grille[i][j]==0){
  fill(0);
  grille[i][j]=1;
}else{
  fill(255);
  grille[i][j]=0;
  
}
noStroke();
rect(j*100,i*100,100,100);
}
if(i<3){
  i++;
}else{
  i=0;
}
}

Merci pour la réponse

Voici le code de la ou j'en suis:

float a = 0;
float b = 0;
float rond01 = 0; // variable pour le balayage

void setup(){
size(200,200);
background(0);

int cols = width;
int rows = height;

// Declare 2D array
int[][] myArray = new int[75][75];

// Initialize 2D array values
for (int i = 0; i < 75; i = i +1) {
  for (int j = 0; j < 75; j = j + 1) {
    myArray[i][j] = int(0);
  }
}

// Draw points
for (int i = 0; i < 75; i = i +1) {
  for (int j = 0; j < 75; j = j + 1) {
    stroke(myArray[i][j]);
    fill(200);
    rect(i * 4 , j * 4, 5, 5);
  }
 }
 
}  // Close setup

void draw(){
  rond01();
  
}

void rond01(){ 
 stroke(200); 
 noFill();
 //rect(a, b, random(5), random(4));
 //stroke(200); 
 noFill();
 stroke(200); 
 ellipse(a, b, random(4), random(5)); 
 
 a = a + 3;
 if(a > width){
 a = 0;
 b = random(200);
 
 }
}

je souhaite que quand le balayage que j'appelle rond01 passe sur un carré qui correspond à une coordonnée
pertinente du dessin, que le carré qui était blanc au départ passe en noir (par ex.)

Je ne sais pas si avec le bout de code que tu m'a donné je pourrai aller vers le but fixé, mais bon je débute et j'avance à taton, et par essais successifs

Là je commence avec un carré de 75 px par 75 px ou l' on voit la grille, ainsi que le processus de balayage.
Dans le projet final je veut ensuite passer à des sketchs plus grand (pour augmenter la finesse du dessin à reproduire) et aussi faire en sorte de ne plus voir ni la grille, ni le pocessus de balayage

J'ai pas bien compris se que tu faisais avec ton ellipse :/, mais voilà le code où tout se change au bon endroit. Je te laisse faire la suite.

float a = 0;
float b = 0;
float rond01 = 0; // variable pour le balayage

void setup(){
size(200,200);
background(0);

int cols = width;
int rows = height;

// Declare 2D array
int[][] myArray = new int[75][75];

// Initialize 2D array values
for (int i = 0; i < 75; i = i +1) {
  for (int j = 0; j < 75; j = j + 1) {
    myArray[i][j] = int(0);
  }
}

// Draw points
for (int i = 0; i < 75; i = i +1) {
  for (int j = 0; j < 75; j = j + 1) {
    stroke(myArray[i][j]);
    fill(200);
    rect(i * 4 , j * 4, 5, 5);
  }
 }
 
}  // Close setup

void draw(){
  rond01();
  
}

void rond01(){ 
 stroke(200); 
 fill(0);
 rect(a*4, b*4, 4, 4);
 stroke(200); 
 noFill();
 a = a + 1;
 if(a > 50){
   a = 0; 
   b = int(random(0,50));
 }
 
}

Et pour une coloration aléatoire (je n'ai ici pas mis de stroke blanc pour les carrés noirs dans un souci esthétique, mais libre à toi d'en mettre un très facilement dans la condition que j'ai mise). Si tu veux faire de "vrais" dessins, il va falloir que tu fasses un tableau en deux dimension ou chaque coordonné correspond à une valeur "noirOuBlanc" égale à 0 ou 1. Bref :

float a = 0;
float b = 0;
float rond01 = 0; // variable pour le balayage
int noirOuBlanc;
void setup(){
size(200,200);
background(0);

int cols = width;
int rows = height;

// Declare 2D array
int[][] myArray = new int[50][50];

// Initialize 2D array values
for (int i = 0; i < 50; i = i +1) {
  for (int j = 0; j < 50; j = j + 1) {
    myArray[i][j] = int(0);
  }
}

// Draw points
for (int i = 0; i < 50; i = i +1) {
  for (int j = 0; j < 50; j = j + 1) {
    stroke(myArray[i][j]);
    fill(200);
    rect(i * 4 , j * 4, 5, 5);
  }
 }
 
}  // Close setup

void draw(){
  rond01();
  
}

void rond01(){ 
 stroke(0); 
 noirOuBlanc = int(random(0,2));
 if(noirOuBlanc==0){
   fill(0);
 }else{
   fill(225);
 }
 rect(a*4, b*4, 4, 4);
 stroke(200); 
 noFill();
 a = a + 1;
 if(a > 50){
   a = 0; 
   b = int(random(0,50));
 }
}

Je sais pas si c'est une très bonne idée de te donner le code tout fait si tu veux apprendre, mais ton projet est sympa, donc j'ai craqué... Essaye de bien le méditer, voir même de le refaire tout seul :)

Au passage, un tableau [50][50] est suffisant (200/4=50 :P)

Merci pour ton aide

Je dois etre effectivement pas très loin du but.

A partir de là écrire le tableau a 2 dimensions pour faire ce dessin
mettre en place la condition.

quand j'aurais des résultat je les posterais

merci en tt cas

Pour pousser le concept plus loin : chaque ligne ne se change qu'une fois par dessin (pas de doublons), de cette manière tu pourras même faire faire ce que tu veux au programme quand le dessin sera terminé. (C'est faisable avec un tableau uni-dimensionnel et un peu d'astuce pour le random)

Tu veut dire que chaque ligne ne passerai qu'une seule fois (dans la distribution verticale) et faire faire
autre chose au programme une fois le dessin terminé

- Soit retourner vers une forme d'effacement, puis repartir vers un autre dessin ?

Bon je vais avancer doucement, mais il dois y avoir moyen de faire des trucs sympa sur ces principe simple :

Uns chute de pixels qui tombent, et certains "restent" pour former le dessin
Ou déclenché par un évenement

Bon va falloir s'y mettre...

merci

T'as tout compris :)
Je pensais aussi à des couleurs, aussi simple qu'en noir et blanc, mais parait plus travaillé.

Pardon pour le gros up, mais après avoir codé ça je me devais de te partager mon idée.

Oui c'est un peu codé avec les pieds et y'a pas mal d'optimisations possibles, mais passons...
Je vais tenter des trucs de mon côté, en espérant t'inspirer.

Superbe

Tu avance plus vite que ton ombre, de mon coté j'ai pas bien avancé, a cause du Taf.
j'ai que peu de temps le soir. Sinon j'ai pas encore trouvé comment "afficher" mon dessin.

En gros j'essais de dessiner comme ça :

{ 


{0,0,0,1,0,0,0,1,0,0,0},
{0,0,0,0,1,0,1,0,0,0,0},
{0,0,0,0,0,1,0,0,0,0,0};

}

Et ensuite que le principe de balayage aléatoire découvre ou sont les "1" et ainsi révéler le dessin

Ton systeme en 3D est vraiment bien et peu deboucher sur un tas d'autre manière de faire et/ou amener des
apparitions de dessin
je vais regarder ton code de près et essayer de comprendre des principes de fonctionnement

Bravo

Etant lycéen j'ai la chance d'avoir du temps libre pour apprendre, je suis pas si méritant...
J'essaye à présent d'explorer les dimensions suppérieures. Je sais pas si c'est utile sur ton projet des dessins en 4d (d'autant que pour l'instant je la représente a peu près comme dans miegakure (http://marctenbosch.com/miegakure/)), mais des que j'aurais fini mon snake 4d sur lequel j'ai commencé à bosser je vois s'il y'a pas moyen d'avoir des choses comme ça : http://mrl.nyu.edu/~perlin/demox/Hyper.html , qui pourrait rendre bien si on y rajoute un quadrillage 4d, pour du pixel art 4d.
Si j'ai le temps, et surtout si j'arrive à garder cette envie.

Edit : Ce fut plus rapide que prévu. Mon snake en quatre dimensions est terminé. Il ne se déroule pas vraiment dans un tesseract car les liens dans la quatrième dimension sont (beaucoup) plus court qu'une arrête du cube. Enfin bref.