jai une image celle ci est parsemee de taches de couleurs  
les taches sont bien separees mais peuvent etre de toute formes
 
comment choper la valeur moyenne RVB de chaque taches?

tj pas de reponse  
meme pas des idees
mais bon que 10 lectures

Le fond est uniforme ?

oui un beau noir parfait

on vas arriver a 25% de programmeurs ne sachant pas resoudre ce pb      
ca fait peur pourtant ca pas l'air d'etre compliqué

si tu pouvais balancer un exemple ...
 
en attendant, si ton fond est tout noir, tu peux y aller 'brute force' : ie tu analyse ton image séquentiellement, et dès que tu tombes sur un pixel non fond (non beau noir parfait) tu appliques un floodfill (voir l'algo récursif magique sur google). sauf que le floodfill ne s'occupe pas de remplir une plage uniforme d'une autre couleur uniforme, mais de calculer la valeur de la couleur moyenne, justement. il faut aussi qu'il update un buffer copie de l'image en marquant les pixels qu'il a 'floodfillés' comme déjà traités.
 
après ce premier floodfill, tu continues le parcours de ton image pixel par pixel jusqu'à ce que tu tombes sur un pixel non traité ou non 'beau noir parfait'. et hop ... tu auras le nombre de tâches et leur couleurs moyennes.

[edtdd]--Message édité par youdontcare--[/edtdd]

une reponse qui vas peut etre m'aider  
  youdontcare.astuce > 35% des informaticiens  
 reste plus ka voir si ca marche
 
je te tien au courant

Tu peux m'envoyer un exemple zippé par mail ?
 
tfj57@yahoo.fr
 
A+

oki je crois ke je vias mettre l'image a traiter en ligne sur le forum ou aux != mails  
 
mais bon vas il y avoir d'autres pb ki vont si greffer (noir pas parfait(avec de legeres variations,et points se cevauchant normalement impossible mais javais une image a traiter et il se chevauchaient parfois,mais le cahier des charge a change   )

faut faire une croissance de région (si j'ai bien compris ce que tu voulais faire, càd, trouver le niveau moyen en RVB des tâches...?)
 
   donc, pour ça, tu tries tes pixels dans l'ordre décroissant (en NdG, car j'ai jamais travaillé en RVB) puis, en partant du pixele ayant le + grand NdG, tu recherches autour tous les pixels supp à un autre NdG, ici, 0 puisque le fond est noir...

il me faut bien la valeur moyenne RVB de chaque taches
 
pour l'instant la solution retenue est le floodfill  
mais vas merder si le font nest pas parfait (mais pouras donner une tolerance pas un pb) mais si la tolerance bouffe les points on verras bien comment ca se presenterras
 
par contre le grand pb c'est quand 2 taches se chevauchent legerement ben le floodfill il vas se planter en beautée
 
pour l'image a traiter elle a 150km de chez moi  
donc la diffuserais par mail dim soir ou avant si je trouve sur le net
 
 
en fait ce chti pb est con mais chaud a la fois a ce que je voit
   
 
donc si vous avez des methode plus radicales faite men part

à part tritouiller les niveaux de tolérance à la main, je vois pas bien de solution magique ...
 
enfin je remarque que dans ton premier post tu précisais que les taches étaient 'bien séparées'
 
si tu n'as pas l'exemple sous la main, ça ressemble à quoi ? c'est une manip connue ? c'est peut-être trouvable sur le net ... (avec l'algo au passage).

koulip31 a écrit a écrit :     par contre le grand pb c'est quand 2 taches se chevauchent legerement ben le floodfill il vas se planter en beautée

 
LeE problème c'est que déja c'est pas clair, comment toi tu fais même "à la main" pour différentier le pixel qui appartiennent à une tache et ceux qui appartiennent à l'autre.  
Imagine si tu as un tache bleu et un tache vert qui se chevauchent au milieu tu auras des pixels jaunes.

bon je reprend tout clairement en mettant le pb dans son integralitee
 
les données:
-je recoit une photo/image (qualite des couleurs mediums donc variation legeres(l'arriere plan.... mais reste noir a l'oeil))
-sur celle ci on voit des taches de differentes couleurs et intensitees et couleurs organisée en tableau (ecartement entre 2 taches en X toujour ou presque identique de meme qu'en Y)
 
le but du prog:
-donc le but est de recuperrer la valeur moyenne RVB de chaque tache et de la stoquer un tableau dans le but de faire des moyennes entre plusieurs images  
 
pb:
-dans la pratique il se peut que les taches se chevauchent (elles ne se melange pas)
-les images ne sont pas de tres bonne qualitées
-l'ecartement des taches n'est pas parfait du tout donc peux pas se baser dessus pour chopper les taches
-c'est des taches ... donc c'est patatoidale (en forme de patate )
-et bien sur trouver le nombre de taches en x et y pour definir notre tableau
 
pour plus d'info:
-l'image a analyser decoule de prelevements sur de l'ADN contenus dans un chromosome et sert a voir l'evolution des genes... jen avais une photo dans mon livre de BIO de ce truc ....  
si kkn se rapele du nom exact ce serrait cool pour aller chercher une image sur le net avant dim (jour oou je pourrais diffuser l'image   )

_________________________________________________________
Imagine si tu as un tache bleu et un tache vert qui se chevauchent au milieu tu auras des pixels jaunes.
_________________________________________________________
 
il se chevauchent mais se melangent pas!!!!  
 
a l'oeil nu ca se voit clairement... mais si japlique un floodfil ben il vas seplanter car avec ce chevauchement il vas traiter les 2 taches d'un coup donc tout fausser

Ben c'est simple tu fais un floodfill avec une tolérence 0.
Théoriquement un floodfill ça ne remplis que une couleur donnée.
Donc que la tache soit entourée par le fond ou par une autre tache sa pose pas de problème.
Certain floodfill accepte une valeur de tolérence mais dans ton cas il faut mettre se valeur à 0.

 
Bin, je vois pas de problème: 2 taches qui se chevauchent=1 tache

---------------------------------------------------------------
Certain floodfill accepte une valeur de tolérence mais dans ton cas il faut mettre se valeur à 0.  
---------------------------------------------------------------
et des qu'il y a une otute petite variation de mon ariere plan il la considere comme une tache ... donc faut que je lui assigne une tolerance (de plus une tache ets constitué d'une couleur et d'une diff d'intensitee) donc des ke l'intensite vas changer le floodfil vas deconner non la meilieur sol reste celle de youdontcare faire un floodfil inverse (tout ce ki nest pas noir ou preske est une tache)
 
----------------------------------------------------------------
Bin, je vois pas de problème: 2 taches qui se chevauchent=1 tache  
----------------------------------------------------------------
ben en fait chaque tache == une donnée biologique  
donc:
 2 taches == 2 données
 et si tu reduit ca a 1 tache ben ca vas etre jolie les resultat d'annalyse .....    

En gros il faut que tu fasse de la reconnaissance de forme.
Donc c'est plus un algo que tu veux c'est un programme d'intelligence artificiel. Parce qu'il y a que ce genre de programme qui peut dicerner des formes aléatoire sur un support non uniforme.
Ou alors il faut que tu acceptes certaines approximations

koulip31 a écrit a écrit : ---------------------------------------------------------------- Bin, je vois pas de problème: 2 taches qui se chevauchent=1 tache   ---------------------------------------------------------------- ben en fait chaque tache == une donnée biologique   donc:  2 taches == 2 données  et si tu reduit ca a 1 tache ben ca vas etre jolie les resultat d'annalyse .....

 
OK, mais is tes taches sont de formes patatoïdes et qu'elles ne sont pas monochromes, ça va être coton pour les différencier.
 
Sinon, tu peux toujours dire que c'est un mutant ou un OGM

c'est comme la selection avec photoshop.. faut une tolérence
 
tu peux aussi faire des opération sur les zone de pixel en cas de seuil critique.
 
du style une tache rouge 84% et une autre de 81% là tu fait une opération en ajoutant du vert pour bien séparer les deux taches

ben ouias pkoi c'est pourkoi jen appele a vous  
pourtant dans l'absolut ca pas laire complexe ....
 
je vais regarder du cote des filtres....  
 

 
ouais mais pas top
me faudrais le nom exacte pour choper une photo
un topic chasse aux mutant dans bla-bla

 
oki la je suis daccord mais pour leur assigner une couleur respective pour les differencier....
 ben faut arriver a les chopper et les separrer pour les colorer donc tu tourne en rond  

tient si tu veux qq liens sur les couleurs
 
http://www.easyrgb.com/index.htm
 
http://www.efg2.com/Lab/Library/Color/Science.htm
 
 
 
c'était dans mon grenier....

ji vais voir mci  

solution avec un minimum d'interface utilisateur :
 
j'ai parlé avant d'un buffer copie de l'image qui serait updaté par le floodfill, afin qu'il puisse détecter quels pixels ont déjà été traités et que tu puisses détecter dans ta boucle de parcours de l'image si le pixel est déjà traité.
 
tu peux étendre un minimum l'algo : le floodfill ne traîtera qu'une tâche à la fois, et remplira le buffer copie avec le numéro de la tâche traitée. une fois le floodfill terminée, il updatera le tableau des 'couleurs de tâche' avec la couleur moyenne trouvée. après le traitement, il faudra que tu parses ce buffer copie et que tu l'affiches par-dessus l'image. si buffercopie[y*with+x] = 0 tu n'affiches rien, sinon tu affiches tableauDesCouleursDeTache[buffercopie[y*width+x]]. tu auras alors la tronche des tâches traitées avec leurs couleurs moyennes.
 
et si je comprends bien, ça foirera sur certaines tâches vu certains problèmes de tolérance : il faut que tu prévoies une mini interface utilisateur qui permette de tracer des segments qui serviront de délimitation entre les tâches.  
 
ie
* tu lances l'algo, il t'affiche le résultat
* tu vois que deux tâches ont été traitées comme une seule
* tu traces une frontière entre ces deux tâches  
* cette frontière sera initialisée dans le buffer de copie à 0xffffff par ex, ce qui empêchera le floodfill d'aller plus loin, toi d'appeler un floodfill là-dessus. tu rajouteras juste un cas dans l'affichage de l'image, if buffercopie[xxx] = 0xffffffff alors affiche du blanc, par ex.
 
au fait je parlais de tolérance dans le floodfill, si une tolérance par pixel ne suffit pas, tu peux essayer une tolérance aux voisins : ie voir si la valeur des pixels adjacents (les 4, les 8, ...) dépasse ta valeur seuil.

je crois ke t viens de resoudre le pb    
 
serrieusement le floodfil est le plus simple et le plus effiace a mettre en oeuvre .
on mavais proposé de faite de la detection de contours mais plus chaud a mettre sur pied.  
 
affaire conclue