Salut a tous, je ne viens pas souvent en ce moment ( foutu job d´été); mais ça ne veut pas dire que je ne fais plus rien...

J´ai créé un petit programme qui fonctionne en ligne de commande qui permet de reconstruire une image avec des miniatures d´autres images.
les images du lien ci dessous expliquerons sans doute mieux que du texte.
http://www.info.univ-angers.fr/pub/letouzey/perso/jeux/screen/mosaique/
dans ce lien, la pluspart des images sont accompagnées de l´originale permetant de mieux évaluer la fidélité du résultat.

Ce sont des photos perso, donc je vous demanderez de ne pas les redistribuer.

Sinon, coté technique, le programme tourne sous linux et il n´est pas portable sous windows (certain processus utilise "mogrify" qui n´esxiste pas sous windows).
La reconstruction d´une image prend environs 5-6 secondes.
Seul la premiere utilisation est longue car elle necessite de créer les miniatures des images servant a la reconstruction. (environs 10 miniutes pour 1000 images)
Plus il y a d´image disponible, plus le résultat est fidele.

Si certain sont interessé, je metrais le programme (et les sources) sur mon site.

Sympa comme programme.

Moi ce qui m´interresse c´est de savoir comment une image est analysé, comment une minuature est declaré plus apte a remplace un pixel ou une zone de l´image source ?

En gros la meme chose que lesquale35 quoi (j´avais pas lu sorry )

sympa !
ça m´intéresse de savoir comment tu as fait

Si j´avais a le faire : voici comment je ferais :
- générer toutes les miniatures
- pour chacun, calculer un "indice de clarté" : une sorte de moyenne de tous les pixels en fait.
pour une image couleur, on peut envisager 3 indices (RGB)
- ensuite, on prend l´image originale, et, soit pixel par pixel, soit par zone (auquel cas on calculera une moyenne de pixels), on cherche la mini image donc les valeurs du "d´indice de clarté" sont la plus proche du pixel (zone de pixels) considérée.
- on termine par du collage...

C´est une idée, a débattre bien entendu. Je suis curieux que tu dises comment tu as fait

il y a aussi une méthode de tricheur (je m´en était servi pour des photos en noir et blanc) qui consiste à prendre une miniature au hasard et à corriger sa luminosité (ça rendrait moins bien si c´était les couleurs évidemment) pour qu´elle colle à la zone où on l´applique.

De pas trop près le résultat est le même, et si on a peu de miniature, c´est bien plus fidèle.

bon ben en faisant la synthese de ce que dit lesquale35 et Fvirtman, il ne reste presque plus rien a redire.
comment ça marche:

1) création des miniatures:
(pour chaque images)
- ouverture de l´image, redimensionnement avec mogrify(la taille peut etre donnée en parametre au programme avec l´option "-taille L H" ou L et H sont des entiers).
- ouverture de la miniatures précedement créée avec SDL
- calcul de la couleur moyenne (moyenne des composantes de chaque pixel)
- enregistrement de toutes ces infos dans un fichier texte contenant la liste des images dispo. pour éviter de tout refaire a chaque fois.

2) division de l´image principale en un pavage intermediaire
- traitement de l´image sous forme d´une grille
- calcul de la couleur moyenne de chaque case
- chaque case a les meme dimension que les miniatures.

3) reconstruction
- recherche pour chacune des "case" de l´image la plus proche (au niveau de la couleur moyenne)
- et pouf on colle une miniature dans chaque case

Les options :
-taille L H : voir plus haut
-triche P : determine le niveau de transparence appliqué a une copie de l´image de base qui est recolé par dessus la mosaique finale; ce petit truc donne de tres bons résultat sans pour autant etre trop visible. (P est en % et pour info, dans les exemples la triche est a 30%)
-prepare : force la création des miniatures
-max : par défaut, la fenetre de l´application est réduite, ce qui accelere grandement la création des mosaique et évite d´avoir une fenetre enorme dans le cas d´une image qui serait plus grande que l´ecran. cette option sert a maximiser la fenetre et permet de voir le programme avancer.
-help : affiche l´aide et quite.
-majoration M : donne la valeur du coeficient de majoration appliqué aux miniatures souvent utilisées pour éviter d´avoir trop de redondances (M est un entier, par défaut c´est 0)

le programme fait 700-800 lignes et m´a pris une vingtaine d´heures.

si des parties manque de clarté, dites le et je rééxpliquerais.

Salut,

je trouve l´idée sympatique. J´avais aussi eu cette idée un jour, mais je ne m´y connaisaais pas assez en programmation pour la réaliser. J´aimerai volontier avoir les sources (je suis aussi sous linux, kubuntu Dapper Drake). Toi, tu as créé combien de miniatures ?

salut qosimo.

Pour les sources pas de probleme. Par contre je n´aurais pas acces a mon ftp avant samedi donc si tu les veux avant file moi ton mail.

Je suis aussi sous Ubuntu. Si tu veux compiler mon programme tu peux deja commencer par installer les package SDL (bibliotheque SDL) et imagemagic (pour convert et mogrify; retouche d´image).

sinon j´utilise environ 1000 miniatures (comme dit plus haut)

voila j´ai (enfin) mis une page sur mon site consacrée a ce programme.
http://www.info.univ-angers.fr/pub/letouzey/perso/jeux/mosaique.php
l´archive a telecharger contient les sources, un makefile et un executable. Je rappelle que ce programme ne fonctionne que sous linux, mais les sources peuvent etre lue par tout le monde. Elles sont assez courtes (700 lignes) et j´ai essayé de metre un maximum de commentaires.

J´aime bien le parametre "triche"

mine de rien il permet d´avoir un résultat beaucoup plus probant sans pour autant que le "spectateur" s´en rende compte...
a 30% on a un bon compromis "resultat / vision de la gruge"

avec "majoration" c´est l´option qui change le plus l´impression generale de réussite de l´image créée.

Salut,

merci de ta réponse, j´avais oublié que j´avais posé cette question, alors heureusement que je viens de voir ton topic !
Je vais télécharger ça tout à l´heure.
En fait, je sais pas si SDL est installé sur mon ordi, parce que j´ai voulu compiler un projet, et ils ont pas reconnus les deux parramêtre mantionnant SDL dans ma ligne de commande. Tu connais une commande qui permette de vérifier que la lib est correctement installée ?
Sinon, toi tu compile comment tes projets SDL ? En ligne de commande, avec un truc genre :

gcc programme.cpp -o programme_bin etc...

Merci

Pour savoir si SDL est bien installé, tu cherches le fichier sdl.h et tu regardes s´il est bien dans ton repertoire include.

Apres, quand tu compiles, avec gcc, n´oublie pas que SDL utilise une lib ou deux, donc il faudra rajouter les parametres -lsdl (et eventuellement -lsdlmain) sous nunux.

je sais pas si c´est encore d´actualité mais:
1) il faut etre sous linux (mias ca je pense que c´est bon vu que je l´ai deja dis plusieurs fois.)
2) pour installer la bibliotheque sdl je suis passé par synaptic (ubuntu).
3) pour les parametre de compilation, il y a un makefile ou est ecrit la commande utilisée.
4) toi pour compiler tu as juste a taper ´make´, sans te soucier du linkage et autres.

le nom exacte du paquet ubuntu doit etre libsdl1.2-dev
peut etre faut il aussi libsdl-image1.2-dev

alors voila je remonte ce vieux topic pour demander des précisions a Fvirtman. (ou autre)

J´ai lu qu tu était spécialisé en image.
Alors voila, je me remet sur ce programme et j´aimerais proposer plusieurs maniere de calculer la "distance" entre une miniature et une zone de l´image de base.

pour le moment
- je calcul la "couleur moyenne" de la miniature et de la zone a remplacer.
- j´utilise une sorte de disatnce euclidienne en 3d (RVB)
- je choisi la miniature la plus "proche" de la zone a remplacer.

j´aimerais savoir si il est possible d´ameliorer cette methode:
- en pondérant plus ou moin telle ou telle composante.
- en prenant une autre representation des couleurs.
- en mixant plusieurs methodes.

j´imagine que la representation RVB est utile et pratique pour un ordi mais qu´il y a mieu pour s´approcher de la perception humaine des couleurs...

merci

ps les liens sont mort : le site était hebergé sur le serveur de mon ancienne fac.