IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Algorithmes et structures de données Discussion :

[Algorithme] Correspondance de points


Sujet :

Algorithmes et structures de données

  1. #1
    Membre éclairé
    Homme Profil pro
    Freelance
    Inscrit en
    Décembre 2003
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Freelance

    Informations forums :
    Inscription : Décembre 2003
    Messages : 423
    Par défaut [Algorithme] Correspondance de points
    Bonjour à tous,

    Je suis à la recherche d'un algorithme (normal vous me direz vu où l'on se trouve dans le forum ...). Je vous explique ce que je cherche :
    Soit deux ensembles E1 et E2. La taille de ces ensembles pouvant être différente. Les éléments de E1 et E2 étant des points (une valeur X et une valeur Y).

    Ce que je cherche à faire c'est, dans la mesure du possible pour tous les éléments de E1, trouver l'élément de E2 le plus proche (pour le calcul de la distance on pourra simplifier par distance(), peut importe ma méthode). Sachant que un élément de E2 ne peut être associé qu'à 0 ou 1 élément de E1.

    Pour le moment je fais ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    // Calcul des distances
    Pour tout e1 élément de E1 faire
      Pour tout e2 élément de E2 faire
        dist[e1,e2] = distance(e1,e2)
      Fin pour
    Fin pour
    associe = 0
    // Traitement de la matrice
    Tant que (associe < size(E1) && associe < size(E2)) faire
       valeur = MAX
       e1c = NULL
       e2c = NULL
       // Recherche de la valeur minimum dans notre table  de distance
       Pour tout e1 de E1 faire
         Pour tout e2 de E2 faire
           si dist[e1,e2] < valeur alors
              valeur = dist[e1,e2]
              e1c = e1
              e2c = e2
           Fin si
         Fin pour
       Fin pour
       Traitement(e1c,e2c)
       // Suppression des distances correspondantes à e2c
       Pour tout e1 élement de E1 faire
         dist[e1,e2c] = MAX
       Fin pour
       // Suppression des distances correspondantes à e1c
       Pour tout e2 élément de E2 faire
         dist[e1c,e2] = MAX
       Fin pour
       incrémente associe
    Fin tant que
    Bon ... c'est l'algo que j'utilise (après évidemment je ne l'ai pas implémenté tel quel ... mais le principe est le même derrière).

    Que pouvez-vous me proposer de plus disons ... performant et peut-être même plus intelligent.
    Je dis intelligent car, admettons la matrice de distance suivante :
    ---------E11-|--E12--|--E13--|-E14
    E21-|--- 3 ---|---2---|---12--|--1
    E22-|--- 7 ---|---7---|---8 --|--8
    E23-|--- 9 ---|---4---|---4 --|--5
    E24-|--- 7 ---|---11--|---11--|--3
    E25-|--- 6 ---|---8---|---12--|--4
    E26-|---10---|---3---|---9 --|--1

    L'algorithme que je donne va donner les appels suivants :
    Traitement(E14,E21)
    Traitement(E12,E26)
    Traitement(E13,E23)
    Traitement(E11,E25)

    Alors qu'une réorganisation des éléments dans les ensembles aurait donnée un autre résultat (ceci à cause des valeurs égales en fait).


    Donc : comment améliorer cet algorithme ? Tant en terme de performance que d'un point de vue ... précision si je puis dire.
    Concernant la performance, sachez juste que, la manière dont j'ai codé l'algorithme, distance n'est qu'un simple tableau à une dimension ... Je le parcours avec seulement une boucle for (pour la recherche du minimum).

    Voilà, j'espère avoir été plus ou moins clair. Si vous avez besoin de plus d'informations, surtout N'HESITEZ PAS à me le dire ... Je détaillerai plus ou je ré-expliquerai les choses différemment ou je ne sais quoi


    Merci de m'avoir lu et de votre éventuelle réponse

    Bonne journée

  2. #2
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Je te suggère une recherche du document "A new point matching algorithm for non-rigid registration", qui explique un algorithme basé sur la meme idée que la tienne.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  3. #3
    Membre éclairé
    Homme Profil pro
    Freelance
    Inscrit en
    Décembre 2003
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Freelance

    Informations forums :
    Inscription : Décembre 2003
    Messages : 423
    Par défaut
    Bonjour,


    J'étais effectivement tombé sur ce paper ... mais je reconnais ne pas avoir eu le courage de le lire sur le coup (je n'étais pas non plus certain que cela correspondait à ce que je cherchais ) ... Mais bon, il semblerait que ce soit le mieux à faire. Du coup je te remercie

    Par contre, si cela ne dérange pas, je laisse le topic ouvert au cas où d'autres personnes désirent contribuer ou autre.
    Si finalement je mets en application ce qu'il y a dans ce paper, je viendrais poster une réponse ici et fermerais le sujet (je l'espère )

    Merci encore et bonne journée

  4. #4
    Membre Expert Avatar de Nemerle
    Inscrit en
    Octobre 2003
    Messages
    1 106
    Détails du profil
    Informations personnelles :
    Âge : 55

    Informations forums :
    Inscription : Octobre 2003
    Messages : 1 106
    Par défaut
    Pour chaque point p, tu construis la liste des points q à distance minimale. Ici à E12 on a associé la liste {E21} et à E14 la liste {E21,E26}.

    Tu commences ton traitement par les points p n'ayant qu'une seul point dans leur liste associée, puis tu passes à ceux qui en ont deux, etc.

    De cette façon tu auras E12<->E21 puis E14<->E26.

    Avantage de ces listes: tu peux y mettre qq points de plus si cela t'arrange...

  5. #5
    Membre expérimenté
    Inscrit en
    Mars 2008
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2008
    Messages : 209
    Par défaut
    Moi je ne vois qu'un simple problème d'affectation ... un algorithme comme la méthode hongroise résous le problème

  6. #6
    Expert confirmé Avatar de Graffito
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    5 993
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 5 993
    Par défaut
    Bonjour,

    Comment se présente la répartition des points dans les ensembles :
    - bornes sur X et Y ?
    - répartion plus ou moins aléatoire ?
    - aggrégats ?
    - essaim ?
    - ...

  7. #7
    Membre éclairé
    Homme Profil pro
    Freelance
    Inscrit en
    Décembre 2003
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Freelance

    Informations forums :
    Inscription : Décembre 2003
    Messages : 423
    Par défaut
    Bonjour à tous,

    @Nemerle >

    J'avais également pensé à un système de gestion de liste. Seulement il existe des situations particulières qui remettent tout en cause avec ce système et je ne vois donc pas comment implémenter cet algorithme proprement par gestion de liste. Je m'explique supposons que parmi les listes on ait :
    E11 => {E21}
    E12 => {E26}
    E13 => {E26,E24}
    E14 = > {E21}

    On se retrouve dans un cas assez gênant (E11 et E14 ont le même ensemble, donc une fois que j'affecte E21 à E11 ... E14 n'a plus de possibilité et je dois refaire mon premier traitement. Mais alors comment faire pour dire "recherche de liste sachant que E14 ne peut pas contenir E21" ? (un algo quelqu'un ? ) ... évidemment penser alors au cas où à E14 est associé un E2X déjà associé à un autre E1Y mais où dist(E14,E2X)<dist(E1Y,E2X) ... oui je sais je suis un peu taquin avec les cas particuliers ... ). En écrivant ces lignes, je viens de penser peut-être à une solution : ne pas conserver juste les éléments les plus proches, mais bel et bien faire une liste ordonnée selon leur distance. Ainsi on aurait par exemple:
    E11 => {E21,E23,E25,E22}
    E12 => {E26,E23,E21,E24}
    E13 => {E26,E24,E22,E25}
    E14 => {E21,E22,E23,E24}
    Le principe ensuite étant de rechercher le premier élément le plus proche ("Pour tout X de E1X, je cherche premier élément de l'ensemble associé le plus proche ..."). Je pense que ça pourrait effectivement marcher ... mais qu'en est-il des performances ? (je vais faire un petit calcul de complexité très rapide là-dessus je pense )
    Merci pour ta contribution quoi qu'il en soit

    @benDelphic >
    Je ne connais pas la méthode Hongroise. Peux-tu détailler un peu plus (de toute façon je vais aller voir ce que nous dit notre ami Google).

    @Graffito >
    Alors, les contraintes sont les suivantes :
    Théoriquement X et Y sont des entiers positifs ou nuls (donc 0 < X < +inf).
    Dans la pratique, +inf n'est pas vraiment concevable. Disons que plus réaliste on peut dire que
    0 < X < 5000
    0 < Y < 5000

    Aucune relation entre X et Y si ce n'est que dist(E1X,E1Y) > SEUIL_MINIMUM

    Répartition totalement aléatoire, par essaim (si je comprends bien la signification (en contradiction à agrégats)).
    Je pense de toute façon que vous l'avez compris, c'est une sorte de système de tracking que je cherche à faire. Je connais un ensemble de positions à un instant t (ensemble E1), j'ai un nouvel ensemble d'éventuelles positions à l'instant t+1, je cherche à dire "ok, cette nouvelle position correspond à cette ancienne là".
    Ce qui, implicitement, suppose que dist(E1X,E2Y)<SEUIL_MAXIMUM (dépendant de la vitesse de déplacement de mes objets)

    Tant que j'y suis, dans l'algo que j'ai implémenté, j'ai apporté une toute petite modification dans la première partie de celui-ci. J'ai juste ajouté un test pour ainsi ne garder que les distances intéressantes (comprendre inférieure à un certain seuil).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // Calcul des distances
    Pour tout e1 élément de E1 faire
      Pour tout e2 élément de E2 faire
        Si distance(e1,e2) < SEUIL alors
           dist[e1,e2] = distance(e1,e2)
        sinon
           dist[e1,e2] = VALEUR_MAXIMALE
        finsi
      Fin pour
    Fin pour
    Merci pour vos contributions

  8. #8
    Membre éclairé
    Homme Profil pro
    Freelance
    Inscrit en
    Décembre 2003
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Freelance

    Informations forums :
    Inscription : Décembre 2003
    Messages : 423
    Par défaut
    (Re)Bonjour,

    @benDelphic >
    Je viens de chercher des informations sur l'algorithme Hongrois. C'est effectivement ce que je cherche à faire. Par contre il semblerait qu'ils travaillent avec des matrices carrées ... ce qui n'est pas mon cas dans 99% des situations. J'imagine que je peux aisément modifier ça.

    Mais alors nouvelle question :
    cela vaut-il le coup que je me lance directement dans l'implémentation de l'algorithme Hongrois ? ou étudier de plus près le document sur "A new point matching algorithm for non-rigid registration" peut apporter une solution plus performante (outre passant l'aspect intérêt de la lecture du document évidemment ... mais auquel cas sa lecture pourrait être repoussée :p)

    Merci encore

  9. #9
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par Bleys Voir le message
    Mais alors nouvelle question :
    cela vaut-il le coup que je me lance directement dans l'implémentation de l'algorithme Hongrois ? ou étudier de plus près le document sur "A new point matching algorithm for non-rigid registration" peut apporter une solution plus performante (outre passant l'aspect intérêt de la lecture du document évidemment ... mais auquel cas sa lecture pourrait être repoussée :p)
    Tu peux au moins essayer l'approche du document : créer une matrice de "probabilité de correspondance", puis la faire converger vers une matrice binaire.

    Exemple (très) simpliste:

    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
     
    int N=4, M=6;
    double[][] proba = new double[N][M];
     
    // convert distance to probability of match
    for(int i=0;i<N;i++)
    	for(int j=0;j<M;j++)
    		proba[i][j] = 1 / (1 + Math.pow( distance(i,j) ,2) );
     
    for(int loop=0;loop<100;loop++) {
     
    	// row/col sum
    	double[] rowsum = new double[N];
    	double[] colsum = new double[M];
    	for(int i=0;i<N;i++)
    		for(int j=0;j<M;j++) {
    			rowsum[i]+=proba[i][j];
    			colsum[j]+=proba[i][j];
    		}
     
    	// try to normalize row and col proba
    	for(int i=0;i<N;i++)
    		for(int j=0;j<M;j++) {
    			double nr=0, nc=0;
    			if (rowsum[i]>0) nr = 1/rowsum[i];
    			if (colsum[j]>0) nc = 1/colsum[j];
    			proba[i][j] = (proba[i][j]*nr) * (proba[i][j]*nc);
    		}		
     
    	// remove lowest (non-zero) proba
    	double min=1.0; 
    	int imin=0, jmin=0;
    	for(int i=0;i<N;i++)
    		for(int j=0;j<M;j++) {
    			if (proba[i][j]>0 && proba[i][j]<min) {
    				min=proba[i][j]; imin=i; jmin=j;
    			}
    		}
     
    	if (min==1.0) break;
    	proba[imin][jmin]=0;
    }
     
    // print result	
    for(int i=0;i<N;i++)
    	for(int j=0;j<M;j++)
    		if (proba[i][j]>=1.0) System.out.printf("E1%d E2%d dist=%f\n",i+1,j+1,dist[j][i]);

    E11 E25 dist=6,000000
    E12 E21 dist=2,000000
    E13 E23 dist=4,000000
    E14 E26 dist=1,000000
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  10. #10
    Membre éclairé
    Homme Profil pro
    Freelance
    Inscrit en
    Décembre 2003
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France

    Informations professionnelles :
    Activité : Freelance

    Informations forums :
    Inscription : Décembre 2003
    Messages : 423
    Par défaut
    Bonjour,

    @pseudocode >
    Merci pour la remarque ainsi que l'exemple ... Je garde ça dans un coin

    Pour être franc, pour le moment je ne vais rien tester de tout ça (méthode Hongroise ou paper), MAIS je n'abandonne pas la question.
    C'est juste que actuellement j'ai un système loin d'être infaillible mais qui fonctionne dans 90% des cas. Ce qui est amplement suffisant pour moi actuellement pour continuer le développement de l'application que j'ai à faire (pour lancer mes tests surtout en fait).

    Par contre, il est certain que je modifierai mon algo plus tard en utilisant tout ce qui a pu être dit dans ce sujet et tout ce qui pourrait éventuellement être encore dit

    Tout ça pour dire que, dans l'immédiat, je ne peux pas vous donner d'exemple de code, ou la solution finalement adoptée, mais je le ferais forcément plus tard (90% des cas, pour l'application finale c'est pas suffisant ).

    Merci pour votre aide précieuse quoiqu'il en soit

    ("Je reviendrais ...." comme dirait Schwarzee à l'époque )

  11. #11
    Membre expérimenté
    Inscrit en
    Mars 2008
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2008
    Messages : 209
    Par défaut
    si tu as une matrice non carrée il suffit de l'augmenter pour avoir une matrice carrée ... ( les éléments étant soit -inf ou +inf suivant l'optimization)

Discussions similaires

  1. matrice fondamentale: algorithme des 8 points et normalisation
    Par MPEG4 dans le forum Traitement d'images
    Réponses: 3
    Dernier message: 15/12/2008, 15h54
  2. 3D tracking : correspondances de points 2d 3d.
    Par TDDev dans le forum Développement 2D, 3D et Jeux
    Réponses: 6
    Dernier message: 26/08/2008, 01h35
  3. Correspondance de points de Harris
    Par faroukus dans le forum OpenCV
    Réponses: 1
    Dernier message: 05/08/2008, 15h57
  4. Réponses: 1
    Dernier message: 05/08/2008, 15h47
  5. Algorithme zone de points sur une image
    Par Alain15 dans le forum 2D
    Réponses: 1
    Dernier message: 08/12/2006, 00h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo