Acquisition de données à partir d'une image

[johnmary]

bonjour à tous.

Voici un sujet qui m'intéresse depuis pas mal de temps, et qu'on retrouve énormément dans l'industrie :
La détection d'anomalie à partir d'une image.

En effet, en industrie il n'est pas rare de trouver sur une chaîne de fabrication, un module effectuant une photo d'une pièce en cours de traitement, pour vérifier si tel ou tel pièce est au bon endroit, conforme etc... et ces photos, à des fréquences parfois décoiffantes.

Malheureusement pour moi... je ne sais pas comment ça fonctionne !

J'imagine (?) Que les logiciels utilisent les couleurs de chaque pixel (?) pour en extraire les informations : Par exemple, pour détecter la présence de peinture sur une pièce, on défini une cible sur la photo, et si la couleur est de ( X < RVB < Y ) alors pièce présente, sinon, défaut ?

Bref, dans un premier temps, ça m'intéresse de connaître comment cela fonctionne, pour ma formation de technicien de maintenance industriel en herbe.
Ensuite, dans un second temps, j'aimerais utiliser ce principe, pour effectuer mon propre alignement de pièce dans le cadre de la réalisation d'une unité à commande numérique de placement de composants CMS sur circuits imprimé. La photo permettrait d'aligner proprement le composant dans sa position finale, après qu'il ait été prélevé dans des supports plus ou moins bien alignés.

Je vous remercie par avance pour toute l'aide que vous saurez m'apporter à ce sujet,
J'ai effectué quelques recherches sur google, mais je ne connais pas les termes précis de cette méthode :/

Merci encore,
Johnmary
-----

[RomVi]

Bonjour

Il existe autant de nombreuses solutions pour détecter une anomalie,on peut par exemple calculer la moyenne des pixels en noir et blanc sur plusieurs zones pour détecter des différences de luminosité (des écarts sur l'axe L), ou le rapport des moyennes des pixels rouges, bleus et verts pour des variations de teinte (écart a ou b).

Si tu veux t'exercer tu peux le faire facilement à l'aide du logiciel Processing.

[Paraboloide_Hyperbolique]

Bonsoir johnmary,

Le monde de l'analyse d'image est très riche et connaît encore de nombreux développements et il existe de nombreux logiciels plus ou moins performants réalisant des opérations de basiques à avancée*. Ne connaissant pas votre niveau, je propose de commencer par un cours présentant les algorithmes de base: http://www-polsys.lip6.fr/~safey/Sli...bloch-2014.pdf

*Par exemple Matlab (ou son équivalent gratuit Octave) possède une toolbox dédiée.

[johnmary]

Bonjour, merci à vous deux pour vos réponses et vos appuis techniques.

Je vais étudier les algorithmes de base afin d'en tirer ceux qui pourraient m'être utiles,

J'ai réalisé ce matin une petite illustration pour vous illustrer ce qui m'intéresse dans mon projet personnel :


J'immagine cela comme ça :
- Définir un repère fixe (Pixel du centre de l'image)
- Déterminer le repère du composant photographié (Moyenne de pixels noirs ?)
- Calculer l'angle entre ces deux repères, et l'alignement des axes verticaux et horizontaux. Trouver la distance correspondant, et corriger.

Ce qui m'intéresse se passe surtout au début :

RomVi, Penses-tu que Processing me permettrait de réaliser ces fonctions ?

Merci encore pour votre aide,
Johnmary

[A voir en vidéo sur Futura]

[Kissagogo27]

quelques exemples indus avec des versions trial
http://www.mcd-elektronik.com/produc...ion.html#c2548

je sais que par exemple chez Cognex, il y a comparaison d'empreintes sur un tapis roulant de sortie de chaîne qui compare les contours en les réalignant par translation ou rotation logiciellement ^^

donc ce que vous recherchez doit être tout autant réalisable

[RomVi]

RomVi, Penses-tu que Processing me permettrait de réaliser ces fonctions ?

Merci encore pour votre aide,
Johnmary

Oui c'est faisable assez facilement, on trace le profil de luminance des pixels sur 2 lignes verticales qui passeront par le composant, on cherche le point de décrochement de ces profils et on calcule l'angle à partir de ces 2 points.
Même chose pour le décalage horizontal, qui lui ne nécessite qu'un seul profil.

Un petit exemple en pièce jointe en image.

[Paraboloide_Hyperbolique]

Bonsoir,

Cela ressemble à ce qui s'appelle en anglais "image registration", peut-être faudrait-il faire l'une ou l'autre recherche dans ce sens.

[johnmary]

Un petit exemple en pièce jointe en image.

Si je comprends bien votre exemple, je peux exploiter le graphique à l'aide d'un programme pour que l'ensemble de teinte > à 120 soit centrée sur l'échelle 0-300 pixels ?

Et refaire le même procédé pour aligner le composant sur l'axe vertical.

Cela a t-il été réalisé avec processing ?

Bonsoir,

Cela ressemble à ce qui s'appelle en anglais "image registration", peut-être faudrait-il faire l'une ou l'autre recherche dans ce sens.

Merci beaucoup pour cet équivalent et traduction technique : je vais faire un tour sur le net voir ce que je peux trouver sur ce sujet.
Cordialement,

Johnmary.

[RomVi]

Si je comprends bien votre exemple, je peux exploiter le graphique à l'aide d'un programme pour que l'ensemble de teinte > à 120 soit centrée sur l'échelle 0-300 pixels ?

Et refaire le même procédé pour aligner le composant sur l'axe vertical.

Cela a t-il été réalisé avec processing ?

Dans cet exemple cette méthode fonctionnerait, il faut voir en fonction de ton cas de figure. On peut aussi faire une dérivée sur les valeurs, pour détecter une variation brusque.
Je n'ai pas effectué cette mesure sur Processing, même si j'aurai pu, car il ne s'agissait que d'une image illustrative (je l'ai fais sur ImageJ).

[johnmary]

Pense tu que ImageJ me permettra de placer mes lignes verticales selon des instructions (Taille du composant sélectionné) et d'en extraire des données (exploiter les graphiques via un algorithme ?)

Ou ImageJ n'est qu'un logiciel de "mesure" sur des images existantes ?

Merci encore,

Johnmary

[RomVi]

A la base ImageJ est conçu comme un outil de biologiste pour faire du comptage de cellules par exemple. On peut écrire des scripts en java qui permettent de s'adapter au besoin.
Par contre il faudra ouvrir une image donnée, puis lancer ce script, pour en tirer par exemple une indication d'inclinaison. Je ne sais pas si ça répond à ta question...
Le mieux serait d'aller jeter un oeil sur le site officiel : https://imagej.nih.gov/ij/

Sinon il y a Labview qui permet de faire du traitement d'image à partir d'une camera, mais le logiciel sera payant cette fois.

[johnmary]

Encore une fois, merci beaucoup RomVi.

Je vais donc tenter ImageJ dans un premier temps (j'ai trouvé plein de documents sur Processing, mais ça me paraît trop complet pour ce que je souhaite faire, sous-entendu trop peu intuitif).

Si je peux introduire l'ouverture d'une image dans un fichier donné dans le programme en Java, ce sera niquel !

Aller, encore un coup : Merci !

[RomVi]

Au 1er abord Processing semble complexe, moi même j'ai attendu longtemps avant de commencer à l'utiliser, surtout que je ne connaissais pas Java, mais en s'y mettant sérieusement avec un bon tutoriel on peut commencer à faire des trucs sympa dans la journée (si tu as des bases en programmation).
D'ailleurs à la base mon besoin ressemblait un peu au tiens : Je voulais ouvrir des images de spectres pour tracer l'intensité de la valeur des pixels dans une application de spectroscopie. En quelques jours, sans y consacrer tout mon temps, j'ai compris les bases et j'ai pu tracer un profil.

[johnmary]

Oui c'est vrai, ce que tu viens d'écrire me rappel mes débuts avec Photoshop. Au début je préférais utiliser des logiciels plus simples, ensuite, avec un peu d'entrainement, j'ai appris à l'utiliser et à comprendre son fonctionnement... Donc je te crois parfaitement !

Du coup, avec ton expérience, que me conseillerais tu sachant que le but est le suivant :

Une carte électronique possède les coordonnées et le type de tous les composants à implanter. Pour l'implanter, elle lit le nom du composant, va le choisir au bon endroit, et sélectionne, et vient le placer au dessus d'une caméra. La caméra effectue une photo et cette photo est instantanément enregistrée dans un dossier, avec un nom défini.
Le logiciel que je devrai utiliser en parallèle devra, sur ordre du micro-contrôleur (BUS SERIE certainement), ouvrir cette image, et déterminer sa position X et Y, ainsi que son angle, renvoyer les valeurs à la carte électronique par bus série. Et enfin le micro-contrôleur corrige l'alignement et la rotation.

Avec ImageJ, j'ai fait deux trois manipulations pour découvrir le logiciel, et j'ai trouvé un outil qui me paraît assez sympa, c'est un petit dérivé du trait que tu a tracé toi, mais avec une épaisseur plus importante : En ouvrant l'échelle des niveaux de gris, la courbe de descente dans les niveaux représente l'angle de mon composant:



avec un autre outil (je pense que ça doit se faire) si je défini une plage sur ce graphique entre 'Gray Value < 220' et 'Gray Value > 150' par exemple, défini sur la moitié des premiers pixels, je peux tracer la droite d'équation (ax+b) la plus représentative, et ainsi trouver l'angle entre cette droite, et l'axe horizontal ?
A moins que je ne fume trop la moquette !

Voila, j'ai découvert ce logiciel, si tu penses qu'il vaut mieux que j'arrête maintenant pour vraiment me concentrer sur processing, je suivrai tes conseils

Merci encore,

[RomVi]

Personnellement je pense que Processing sera moins limitant, notamment en terme de communication avec le micro contrôleur. Beaucoup l'utilise en complément d'un Arduino par exemple.

[johnmary]

Coucou !

Bon, j'ai téléchargé Processing, ça me semble effectivement assez complet !

J'ai déjà reussi à ouvrir différentes images (de composants différents) en modifiant une variable ..

EX : Si le micro-contrôleur indique que le composant à placer est de type DIP16, alors il ouvre l'image nommée DIP16.jpg.
_{Oui, bon, rien de bien exceptionnel en soit !}

Pour m'aider à avancer, connaîtriez vous quels outils je peux utiliser pour commencer la démarche d'alignement ?

Merci encore !

[RomVi]

Il faut déjà se familiariser avec certaines fonctions, pour récupérer la valeur d'un pixel et les stocker dans une variable type tableau pour récupérer une ligne de pixel, les tutoriels ne manquent pas.
Pour ma part j'ai beaucoup utilisé ces 2 adresses :
http://hyperbate.fr/dernier/?p=2890
http://www.ecole-art-aix.fr/rubrique81.html

[johnmary]

Merci pour ces bons liens

Il me reste plus qu'à trouver LA technique à utiliser pour pouvoir arriver à mes fins

[johnmary]

Bien, pour trouver l'orientation de mon composant, je pense avoir trouvé une trame qui peut fonctionner :

1- Créer un tableau contenant chaque pixel à l'aide de l'outil loadPixel();
2- Scanner chaque colonne une à une en partant de la gauche, jusqu'à trouver celle présentant le premier pixel noir (120)
3- Mémoriser le pixel en question
4- Scanner chaque ligne en partant du bas, jusqu'à trouver celle présentant le premier pixel noir (120)
5- Mémoriser le pixel en question
6- A l'aide des coordonnées des deux pixels définir l'équation d'une droite
7- Definir mathématiquement l'angle entre la droite définie à l'étape 6 et la droite de référence (horizontale)

Et voila

Maintenant, malgré mes recherches, je ne parvient pas à exploiter les coordonnées d'un point.
Exemple : Si je souhaites les coordonnées du point n°423 (au hasard) dans le tableau de pixel, comment faire ?, Comment les stocker ?

J'ai réussi toutes les étapes pour scanner les pixels un à un, mais je ne parvient pas à définir les coordonnées

Si quelque chose vous vient en tête, je suis preneur !
Merci milles fois !

[RomVi]

Oui c'est une bonne méthode. A noter que tu peux aussi scanner les points un par un et calculer la différence avec le précédent pour trouver le décrochement (pour s'affranchir des différences de luminosité).

Je ne suis pas sur de bien comprendre ta question, mais si tu veux stocker les coordonnées de tes points il suffit d'utiliser une variable. Tu peux en utiliser une par point et par coordonnées, par exemple X1, Y1, X2.. ou plus simplement utiliser une variable de type tableau à 2 dimensions qui pourra stocker toutes tes valeurs : http://wiki.t-o-f.info/Processing/Tableau

[johnmary]

En fait ma difficulté est de savoir comment affecter la position (que ce soit X ou Y) dans une variable :

Lorsque je suis sur le pixel < 120 dans le tableau, j'aimerais enregistrer ses coordonnées avec une formule qui ressemblerait à la suivante :

" X1 = pixels[position,x]"
" Y1 = pixels[position,y]"

for(int position = 0; position < pixels.length; position++) {
   float x= brightness(pixels[position]);
   if(x < 120){
// J'aimerais enregistrer les coordonnées du pixel ICI :)
   }

Malheureusement je ne trouve pas la structure à utiliser pour exploiter les coordonées :/

[RomVi]

Désolé, j'avais oublié ta question.
Il y a plusieurs façons de faire ce que tu veux, mais le plus simple à mon avis serait plutôt d'utiliser une boucle "do while" : Dans la boucle tu augmentes la valeur de position à chaque bouclage
position = position +1, et comme condition de sortie tu reprend le même test que tu ce que tu as fais plus haut.
Lorsque la condition est respectée la boucle est interrompue, et la variable position est alors égale à la position du pixel qui t’intéresses.

[johnmary]

Mais la position dont tu me parles, ne s'agit-il pas de la position du pixel dans le tableau des variables ?

Le pixel (0;0) sera positionné en 0
Le pixel (0;1) sera positionné en 1
Le pixel (0;2) sera positionné en 3
Le pixel (0;3) sera positionné en 4

Et ainsi de suite,

Mais qu'en est-il pour récupérer la position réelle du pixel à partir de sa position dans le tableau, c'est à dire :

Savoir que le pixel n°365 est aux coordonnées (12;54) ?

A moins que ton idée est de faire, en parallèle du code qui check chaque pixel pour déterminer son niveau de gris, une boucle qui incrémente en partant de (0;0) et qui s'arrêtera en même temps que la boucle "J'ai trouvé le premier gris" (Attention à ne pas sortir du contexte...) ?

Merci encore,

[RomVi]

Bonjour et désolé pour la réponse tardive

Je ne comprend pas très bien la question, ce qui t’intéresse est de savoir où se trouve le pixel qui marque le décrochement non ?

[johnmary]

Oui, d'obtenir sa position physique dans l'image (En coordonnées x; y) et pas sa position dans le tableau des variables

[RomVi]

Dans ce cas il n'y a pas de problème. Admettons que tu balayes une colonne pour y = 100. Tu fais donc varier la valeur de la ligne dans la boucle.
Tu as un algorithme du type :

répéter :
  x= x+1
  lire la valeur du pixel x,100
  si valeur du pixel < 120 ou si x dépasse la taille de l'image sortir de la boucle
boucler

position du décrochement = x, 100

Lorsque tu sors de la boucle x cesse d'augmenter, donc il conserve la valeur qu'il avait lors du décrochement.

[johnmary]

Super ! c'est bien ce que j'avais un peu en tête, mais ce n'était pas clair. Il me restera à faire la même chose en balayant depuis le bas pour obtenir le second pixel.

Je vous tiens au courant de la tournure du projet

Merci !

[johnmary]

Bonjour à tous !

Après quelques petites lignes, j'ai réussi à faire la première étape :

Scanner chaque pixel en partant du haut à gauche pour trouver le 1er coin du composant
Scanner chaque pixel en partant du bas à droite et en remontant vers le haut à droite, pour trouver le 2nd coin du composant.

Du coup j'obtiens bien mes deux points, et j'arrive parfaitement à tracer la droite le long du bord (il faudra cependant faire attention à ce que les photos soit parfaitement prise sur le dessus, au risque de ne pas trouver exactement le bord). :

1.png

Je trace ensuite une droite au milieu de l'image pour définir l'angle à obtenir.

Malheureusement je n'arrive pas à calculer le coefficient directeur de cette droite...

J'ai bien défini une variable de type double, ou float pour "cdir"
et j'effectue le calcul suivant :

2.png

Les soustractions fonctionnent bien, c'est la division qui semble poser problème, ou alors le type de variable utilisé ?
Je sèche

En tous les cas merci encore pour m'avoir guidé jusqu'ici !

[RomVi]

Bonjour johnmary

C'est peut être un problème de type de variable en effet. Par contre je ne pourrais m'y pencher qu'après les fêtes, en attendant pourrais tu poster tout ton code ?

[johnmary]

Coucou, aucun problème, le voici :


Bon c'est le bordel hein... y'a des variable qui servent à rien, des indentations non respectées... pas de commentaire :P
En général j'élague à la fin

PImage img; // Déclare la variable a en type d'image
int val = 16; // Définir ici pour le moment la taille du boitier, ça charge l'image en conséquence.
int X1, X2, Y1, Y2;
int C1, C2, C3, C4, C5;
int position, vmax;
float x, cdir;
boolean M3, M4;

void setup() {
  size(200, 200);
  C4=200;
  
  if(val == 16){
      img = loadImage("DIP16.jpg");  // Load the image into the program  
  }
  if(val == 8){
      img = loadImage("DIP8.jpg");  // Load the image into the program  
  }


 loadPixels();
  
}

void draw() {
  
  image(img, 0, 0);
  loadPixels();
  loop();
}

void loop() {
  

while(M3==false){
  
  if(position < pixels.length){
    position++;
    C1++;
    X1++;
    x= brightness(pixels[position]);
    }  
    
   if(C1>=200){
     Y1++;
     C1 = 0;
   }
  if(X1==200){
     X1 = 0;
  }
 
  if(x <= 60){
  print("X1=");
  println(X1);
  print("Y1=");
  println(Y1);
  stroke(0,255,0);
  point(X1,Y1);
    M3 = true;
    
   }
}

while(M3 == true && M4 == false){
  vmax = pixels.length;
  position = (vmax-C5);
  position = position - C4;
  C4 = (C4+200);
  C3++;
  
  if(C3 >= 199){
  C5++;
  C3 = 0;
  C4 = 200;
  }
  
  X2 = 200-C5;
  Y2 = 200-C3;
  
  point(X2,Y2);
 
  x= brightness(pixels[position]);

 if(x <= 60){
  print("X2=");
  println(X2);
  print("Y2=");
  println(Y2);
  stroke(0,255,0);
  point(X2,Y2);
  cdir = ((Y2-Y1)/(X2-X1));  // •••••••••• NE RETOURNE PAS LA VALEUR ... PB ENTIER ?
  print("a=");
  println(cdir);
  

    M4 = true;
   }
  
}

if(M4 == true){
  line(X1,Y1,X2,Y2);
  line(0,100,200,100);
}
}