Forum de mathématiques - Bibm@th.net

salut,

Précision :
j'ai  2 images ,chacune est sous une taille de 16*16,  (une mémorisée et l'autre courante) segmentées en blocs carréés et je souhaitrais écrire l'algorithme  d'estimation de mouvement  3SS  (three step search) en langage C  en utilisant comme critère de comparaison  le SAD (somme des différences absolue).

merci.

+--------------------------------------------------+
+                Essaie avec Qt 4.x               +
+--------------------------------------------------+
// --> supposons que ton image est codée  sur 32 bits

#include <QtGui>
#include <SAD.h>
#include <math.h>
#include <iostream>

//taille maxi des images
int x =0x190 ,y =0x258;

QPoint taille_image(x,y);
// l'image est mis sous un format de 32 bits a la taille taille_image

QImage pixmap1(taille_image,QImage::Format_RGB32);
QImage pixmap2(taille_image,QImage::Format_RGB32);

// création du constructeur SAD qui prend en entrée la taille de la région sur les images ou l'on veut calculer le SAD et les deux images

qreal SAD::SAD (int m_value, int n_value, QImage *im1, *im2)

{
   im1 = pixmap1; 
   im2 = pixmap2;
   if(m_value >= x || n_value >=y) // la position des pixels ne doit pas dépasser x et y(taille de l'image)
                              {                               
       QMessageBox::Erreur1(this, tr("Error Size"), tr("La position entrée est supérieure a   la taille de l'image"));
                              }
     for(int index1 = 0; index1 <m_value;index1++)
                             {
      for(int index2 = 0; index2 <n_value;index2++)
                                   {                       
                             Qrgb pix1 = im1->pixel(index1,index2);
                             Qrgb pix2 = im2->pixel(index1,index2);
                             QColor convert1 = fromRgb (pix1);
                             QColor convert2 = fromRgb (pix2);
                             int intens1 =0,intens2 =0;
                     bool testcolor1 =(convert1 == (QColor(Qt::Gray)||QColor(Qt::darkGray)||QColor(Qt::lightGray)));
                     bool testcolor2 =(convert2 == (QColor(Qt::Gray)||QColor(Qt::darkGray)||QColor(Qt::lightGray)));
                             if(testcolor1 == 1)
                                                       {
                                                           intens1++; // intensite du gris a la position (index1,index2) de l'image 1
                                                           int  I1[index1,index2] = intens1;
                                                        }
                             else if ( testcolor2 == 1)
                                                        {
                                                            intens2++; // intensite du gris a la position (index1,index2) de l'image 2
                                                            int I2[index1,index2] = intens2;
                                                          }
                             else  index1++;index2++; // on passe au pixel suivant lorsqu'on ne trouve pas le gris

                                       }                     
                             }
                             
                        // calcul du SAD
                      qreal  som = 0;
                      for(int index1 = 0; index1 <m_value;index1++)
                             {
                      for(int index2 = 0; index2 <n_value;index2++)
                                   {                       
                                      som = som +(1/(m_value+n_value))*fabs(I1(index1,index2) - I2(index1,index2));     
                                    // on somme de maniere iterative ecart moyen
                                    }
                              } 
                             return som;
}

SAD::~SAD()
{

}
//-----------------------------------------------------------------------------------------------------------------
// --> ou que tu charge une image a travers ton bureau
// utiliser la classe QPixmap

+--------------------------------------------------+
+                Essaie avec Qt 4.x               +
+--------------------------------------------------+
// --> supposons que ton image est codée  sur 32 bits

#include <QPixmap>
#include <QtGui>
#include <SAD.h>
#include <math.h>
#include <iostream>

//taille maxi des images
int x =0x190 ,y =0x258;

QPoint taille_image(x,y);

// definition des chemins des images
Qstring dir1 ="C:\Administrateur\image1.png";
Qstring dir2 = "D:\Administrateur\image2.png";

QPixmap pixmap1(dir1);
QPixmap pixmap2(dir2);

// l'image est un pixmap  a la taille taille_image
pixmap1.resize(taille_image);
pixmap2.resize(taille_image);

// création du constructeur SAD qui prend en entrée la taille de la région sur les images ou l'on veut calculer le SAD et les deux images

qreal SAD::SAD (int m_value, int n_value, QPixmap *im1, *im2)

{
   im1 = pixmap1; 
   im2 = pixmap2;
   if(m_value >= x || n_value >=y) // la position des pixels ne doit pas dépasser x et y(taille de l'image)
                              {                               
       QMessageBox::Erreur1(this, tr("Error Size"), tr("La position entrée est supérieure a   la taille de l'image"));
                              }
     for(int index1 = 0; index1 <m_value;index1++)
                             {
      for(int index2 = 0; index2 <n_value;index2++)
                                   {                       
                             Qrgb pix1 = im1->pixel(index1,index2);
                             Qrgb pix2 = im2->pixel(index1,index2);
                             QColor convert1 = fromRgb (pix1);
                             QColor convert2 = fromRgb (pix2);
                             int intens1 =0,intens2 =0;
                     bool testcolor1 =(convert1 == (QColor(Qt::Gray)||QColor(Qt::darkGray)||QColor(Qt::lightGray)));
                     bool testcolor2 =(convert2 == (QColor(Qt::Gray)||QColor(Qt::darkGray)||QColor(Qt::lightGray)));
                             if(testcolor1 == 1)
                                                       {
                                                           intens1++; // intensite du gris a la position (index1,index2) de l'image 1
                                                           int  I1[index1,index2] = intens1;
                                                        }
                             else if ( testcolor2 == 1)
                                                        {
                                                            intens2++; // intensite du gris a la position (index1,index2) de l'image 2
                                                            int I2[index1,index2] = intens2;
                                                          }
                             else  index1++;index2++; // on passe au pixel suivant lorsqu'on ne trouve pas le gris

                                       }                     
                             }
                             
                        // calcul du SAD
                      qreal  som = 0;
                      for(int index1 = 0; index1 <m_value;index1++)
                             {
                      for(int index2 = 0; index2 <n_value;index2++)
                                   {                       
                                      som = som +(1/(m_value+n_value))*fabs(I1(index1,index2) - I2(index1,index2));     
                                    // on somme de maniere iterative ecart moyen
                                    }
                              } 
                             return som;
}

SAD::~SAD()
{
    return 0;
}

// il est à noter que :
--> le choix de l'un de ces codes sources dependent de l'espace memoire en terme d'espace et graphique
soit 32 bits ou 64 bits

Salut,

Désolé
1. Je ne comprends pas un traître mot de ce que tu dis : chercher la correspondance, corrélation, carte de disparité... kessékça ? Tout le monde n'est pas versé dans le traficotage informatique des images...
2. Je ne comprends pas non plus ce que tu veux faire avec ta formule ni ce que représentent les diverses variables.
[tex]SAD= \frac{1}{m+n} \sum_{i=1}^m\sum_{j=1}^n |I_1 (i,j) - I_2 (i,j)|[/tex]
Au passage, ceci au-dessus est quand même plus lisible, non ? Tu pourrais te mettre aussi à Latex, non, depuis le temps ?

Donc commence par prendre le temps d'expliquer la théorie, SVP... Tu as négligé de le faire voulant gagner du temps, c'est raté !

Bon, alors pour moi la différence de deux points, ça n'existe pas, fussent-ils des points d'une image...
I1 et I2 ne sont peut-être pas des points ?
Ce sont peut-être des images ? (la différence des valeurs absolues de deux images, ça n'existe pas non plus !)
Et (i ; j) les coordonnées d'un point quelconque d'une image.
Quel est le principe de ce que tu veux faire ?
Je suppose que tu disposes de deux images A et B.
Cherches-tu à "comparer" chaque point de l'une avec chaque point de l'autre ? Et si elles n'ont pas le même nombre de points ?

@+

[EDIT]
J'ai trouvé à quoi rime ce jargon, mais tu aurais pu aussi donner des liens :
http://fr.wikipedia.org/wiki/Somme_des_ … s_absolues

Et celui-là, c'est toi :
http://www.developpez.net/forums/d12021 … -absolues/  ???
Sûrement ! nomadstorm et stormin ont storm en commun... L'intro est la même...
Et après lecture de la discussion et de ton programme, je doute qu'on puisse t'aider.
M'enfin, je vais essayer d'y réfléchir : faudra pas être trop pressé...