Reconstruction de la Joconde

[juan]

Comment faire pour reconstruire le portrait de la Joconde à partir de 6 images qui n'ont rien à voir, pour obtenir ceci:



Les images d'origine sont disponible dans le sujet du concours:
http://fr.creationarena.com/contest-137.html

Revoici l'explication du principe général: j'ai écrit un programme avec Processing (du java pour faire des trucs). Le programme mémorise les 6 images de référence et une septième (la joconde), puis va créer une huitième image à partir de tout cela. Pour chaque pixel de l'image 8, le code recherche parmi les 6 images celle dont le pixel a la couleur la plus proche du pixel correspondant dans l'image de la joconde. Une fois cette image trouvée, le pixel de cette image est recopié dans l'image huit. C'est ce qui donne le côté morcelé du visage de la joconde sur l'image finale. Si on fait exactement cela pour tous les pixels, on obtient quelquechose de très proche avec la Joconde (ca marche beaucoup moins bien avec "La laitière"). Mais pour qu'on voit mieux les images d'origine, le programme prélève des pixels pour le centre et des bouts complets d'image pour le tour. Tous les pixels de l'image finale sont donc bien extraits des images d'origine. Aucun pixel de l'image 7 n'est prélevé, donc le défi est relevé. La joconde n'est qu'une source d'inspiration: la référence.

Voici le code commenté (commentaires en vert avec "//"):

------------------- le code ----------------------

// déclaration des principales variables
int i, j, sx, sy, numpix;
int cote;
int compteur, coul, dir;
float distopt, disttemp;
float marge = 0;
float rouge, vert, bleu, rougetemp, verttemp, bleutemp, rougeopt, vertopt, bleuopt;
int loc;
PImage b, im1, im2, im3, im4, im5, im6, imopt;


void setup(){
b = loadImage("reference.jpg"); // on charge la joconde
im1= loadImage("image5.jpg"); // on charge les 6 images
im2= loadImage("image1.jpg");
im3= loadImage("image2.jpg");
im4= loadImage("image3.jpg");
im5= loadImage("image4.jpg");
im6= loadImage("image6.jpg");
size(b.width, b.height); // dimensions
sx = width; // variable définissant la largeur
sy = height; // -- et la hauteur de l'image finale
background(0);

cote=1;

// pour chaque pixel (i,j) de l'image
for (int i = 0; i < sx-1; i=i+1) {
for (int j = 0; j < sy-1; j=j+1) {

if (red(get(i,j))+blue(get(i,j))+green(get(i,j)) < 1) {
// pour chaque pixel noir de l'image
// on calcule les 6 distances de couleurs entre les images et la référence

loc = int(int(i) + int(j)*b.width); // loc est le numéro du pixel dans l'image
rouge = red(b.pixels[loc]);
vert = green(b.pixels[loc]);
bleu = blue(b.pixels[loc]);

// là, on a trouvé la couleur du pixel dans la joconde
// on regarde le meme pixel dans l'image 1
// et on calcule la difference de couleur "disttemp"
// qui est pour l'instant la plus petite (distopt) car on a testé qu'une image

rougetemp = red(im1.pixels[loc]);
verttemp = green(im1.pixels[loc]);
bleutemp = blue(im1.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
distopt=disttemp;
imopt=im1;

// on refait ensuite pareil pour l'image 2
// si disttemp de l'image 2 est plus petite que distopt, ca veut dire que le pixel est plus proche de la Joconde, donc que l'image 2 est l'image optimale

rougetemp = red(im2.pixels[loc]);
verttemp = green(im2.pixels[loc]);
bleutemp = blue(im2.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
if (disttemp < distopt - marge){
distopt=disttemp;
imopt=im2;
}

// On fait pareil pour les images 3,4,5, et 6, sur le meme principe.

rougetemp = red(im3.pixels[loc]);
verttemp = green(im3.pixels[loc]);
bleutemp = blue(im3.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
if (disttemp < distopt - marge){
distopt=disttemp;
imopt=im3;
}

rougetemp = red(im4.pixels[loc]);
verttemp = green(im4.pixels[loc]);
bleutemp = blue(im4.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
if (disttemp < distopt - marge){
distopt=disttemp;
imopt=im4;
}

rougetemp = red(im5.pixels[loc]);
verttemp = green(im5.pixels[loc]);
bleutemp = blue(im5.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
if (disttemp < distopt - marge){
distopt=disttemp;
imopt=im5;
}

rougetemp = red(im6.pixels[loc]);
verttemp = green(im6.pixels[loc]);
bleutemp = blue(im6.pixels[loc]);
disttemp=(rouge-rougetemp)*(rouge-rougetemp)+(vert-verttemp)*(vert-verttemp)+(bleu-bleutemp)*(bleu-bleutemp);
if (disttemp < distopt - marge){
distopt=disttemp;
imopt=im6;
}


// tracé
// on calcule le cote de la zone qu'on va extraire de l'image optimale pour qu'on ait des petites zones au milieu et des gros rectangles sur les cotés.
cote=constrain(int(((i-250)*(i-250)+(j-175)*(j-175))/5000),1,20);

for (int x = 0; x < cote; x=x+1) {
for (int y = 0; y < cote; y=y+1) {
// on recopie tous les pixels de la zone rectangulaire
loc = int(int(i+x) + int(j+y)*imopt.width); // loc est le numéro du pixel dans l'image
if (loc < 187000) {
rouge = red(imopt.pixels[loc]);
vert = green(imopt.pixels[loc]);
bleu = blue(imopt.pixels[loc]);
stroke(rouge, vert, bleu);
point(i+x,j+y); // on recopie les pixels
}
}
}
} // fin du if
}
}
// }

// on sauve l'image finale
save("jocondereconstruite.tif");

}

void draw(){ // boucle infinie qui ne sert pas ici
} // fin de void loop

---------------------------------------------------

Et voila votre magnifique Joconde toute torturée...

[loup]

pffff ok trop complexe
j'attends l'explication de jimic


passq tout ça, tu le tape ou ? dans quoi ? avec quoi ?
c dommage de pas parler l'informatique !!
j'aurais du prendre ça en 3eme langue etrangère

[jimic]

pas d'explication, car moi et le code, on a du mal.

je peux dire que :
il manque un bout de vert dans le code (c un retour à la ligne oublié)
la technique que j'ai supposée dans le forum "valideurs" peut donner un résultat voisin mais avec beaucoup de patience...
le résultat est magnifique et c hapeau pour l'ID

(j'aime moins le coté process qui me fait penser à mon fond d'écran aux fractales et aux boites à rythmes en général)

[jimic]

bon, explication quand même pour loup, même si je me plante.

on fait ici 1 peu la même chose que quand on réduit le nombre de couleurs d'une image, ou qu'on l'augemente, ou qu'on modifie les dimensions, ou sa def, enfin etc .... on teste la valeur d'un élément (pixel notament) par rapport à son environnement ou à des images de référence.

mais on le fait pas à l'échelle du pixel, mais pour une dimension d'échantillon variable (avec les grosses plages autour ?)





les ordis battent les meilleurs joueurs d'echecs au monde.
je vais me mettre au binage de topinambours

[juan]

Je fais juste une parenthèse dans votre discussion pour revenir sur la remarque de Jimic, qui "n'aime pas le côté process". Moi parfois j'aime bien cela, mais pas tout le temps. J'explique. C'est brut et en bordel...

Sans vouloir partir dans l'histoire de l'art que je ne connais pas assez et que j'ai souvent du mal à comprendre, j'ai l'impression que souvent, la démarche de l'artiste autant du point de vue technique que du point de vue création tient une place importante, sans tomber pour autant dans la prouesse technologique. Est-ce que je peux citer la perspective, qui est quand même un process de construction graphique ?

L'autre face de ma remarque, c'est la possibilité de détournement qu'offre l'existence d'un process, d'un principe de construction. Briser la perspective est devenu un effet classique. Beaucoup d'algorithmes de construction numérique (fractales, automates cellulaires...) ne donnent qu'un résultat banal si on les prend au premier degré. Mais si on les détourne, il peuvent donner des choses très variées et qui là deviennent vraiment créatrices, enfin je crois. J'essaierai peut-être de le détourner pour voir ce que ca peut donner.

Remarque terminée, vous pouvez rediscuter.

[loup]

euh jimic tu t endormi ?

[jimic]

bah nan loup, mais je voyais rien à rajouter ... ya aut' chose ?
ma tentative de traduction du "juanien" était peut être quelque peu trop sommaire et synthétique ?

Je vais essayer autrement :
Pour dessiner par exemple le bas de la joue et le menton de mona-lisa, c'est le contraste entre la zone sombre du cou et du dessous des cheveux et la zone claire du bas du visage qui fait ressortir la ligne de contour du visage.
Il faut donc prélever dans les images sources du concours des pixels sombres pour le cou, et clairs pour le visage, et les placer dans une nouvelle image (qui sera l'image finale), à l'endroit voulu. Et pour que ca fasse une ligne aussi précise que possible, de façon à ce qu'au final les traits et volumes du visage soient discernables, il faut travailler à l'echelle du pixel dans les zones ou on veut le plus de détails.

Tu peux donc faire la même chose manuellement, "à l'oeil", pour choisir quels pixels copier-coller, ou quels pixels effacer pour découvrir l'image voulue en dessous si tu travaille sur une pile de calques. Pour les zones peu ou pas détaillées, ca va viote, pour les zones à détailler c'est très long.

Juan a donc écrit un petit programme en "java-pour-faire-des- trucs" (voir forum sur je ne sais plus quel sujet ou on avait parlé du java, des applets et tout ca...) qui fait le choix des pixels et les colle automatiquement.

bon, bin j'espère que c'est plus clair là.
sinon, juan pourra surement te préciser ca mieux que moi.

[juan]

Non, moi je n'ai rien à ajouter. Ce que j'attends de voir, c'est le résultat et surtout entendre les commentaires de celui qui aura essayé de le faire manuellement ! Il y a quand même 187000 pixels dans l'image... S'il vérifie la couleur sur les 6 images, ca fait plus d'un million de manipulations de calques. S'il est très très rapide, à 10 manip par seconde, ca fait 100000 secondes, avec 3600 secondes de l'heure, ca fait 33 heures !!! Et 33 heures pour ça, c'est cher payé !

[loup]

bon juan tu le tape ou ton code ?

[juan]

Excuse-moi, Loup, j'avais oublié cette question. Pour faire tourner le code ci-dessus, il faut que tu installes le logiciel libre qui s'appelle "Processing". Tu peux le trouver ici:

http://processing.org/download/index.html

Donc tu télécharges le zip, tu le dézippes, tu installes le logiciel: tu peux avoir confiance, c'est développé par le Media Lab du MIT. Ensuite quand tu lanceras le logiciel (il faut peut-être aller chercher l'executable, c'est pas toujours clasique.), tu verras une fenetre apparaitre. C'est là qu'il faut taper le code. Mais regarde d'abord les exemples qui sont fournis avec le logiciels.

Voila, dis-moi si tu as des problemes.

[jimic]

suis d'accord juan, quoique, seul le visage etant détaillé, je pense que ca représente moins de 1/9 ème de l'ensemble, soit 18700 px environ, soit 3 à 4 h de boulot en étant "trés rapide".

mais je voyais plutôt genre 5 à 6 heures.
et j'ai essayé de le faire manuellement (quand on a eu l'image en validation), et c'est pas de la tarte !

[0eillades]

Complètement foufrappadinguefurieux, ces artistes

[juan]

Oeillades, quelle étroitesse d'esprit !

Fallait-il considérer comme frapadingues les cubistes, les expressionnistes, les dadaistes ? Ou fallait-il les voir comme des explorateurs, des expérimentateurs, libres d'essayer à l'encontre des visions construites, libres de découvrir des sensations bizarres, enthousiastes qu'ils étaient d'avancer tout branlant sur les chemins herbeux qui les menaient vers des contrées lointaines ? Fallait-il les juger avant que l'histoire de l'art n'en ait fait des pionniers ? Ou faut-il encore ne plus chercher à se faire plaisir ? Faut-il encore pondre dans des moules ? Faut-il faire des cakes calibrés ?

[0eillades]

Oh juan, arrête de tout prendre au pied de la lettre ! D'une part c'était plutôt admiratif, d'autre part ça se rapportait non à ta recherche mais au fait que jimic commence à passer des heures juste pour voir comment reconstituer ce que tu avais déjà fait d'une autre manière ! Je vous trouve parfois un peu "fous furieux de l'art" et je vous envie