Bonjour

Je suis entrain de créer une fonction servant à lisser une image, en supprimant le bruit.

Cependant, je bloque sur une erreur SIGSEGV qui se trouve dans cette méthode.
Avez vous une idée d'où peut provenir l'erreur ?

info: - Je commence mes attributs par "m_"
- J'utilise code::blocks

edit 20h04: (
remarque: Après plusieurs test avec des images .png , cette fonction marche pour certaines et fait SIGSEGV pour d'autres. )

Voici la fonction:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
/*------------------------------------*/
//supprimer le bruit <=> lissage
/*------------------------------------*/
void ImageMod::smoothing(int proximity)
{
    //si jamais l'image n'est pas en niveau de gris.
    if(m_image->nChannels!=1)
        return;
    //On vérifie que le voisinage est impair sinon on le corrige
    if(proximity%2==0)
        proximity++;
 
    CvScalar pixel;
    //déclaration de l'image intermédiaire: image de stockage.
    int flip = origin(m_image);
    IplImage* imgSmooth = cvCloneImage(m_image);
 
    CvRect roi=cvRect(0, 0,proximity,proximity);
    //tableau pour récupérer les valeurs des pixels dans la zone ROI
    vector<int> neighbour(proximity*proximity);
 
    for(int y=0; y < m_image->height; y++)
    {
        for(int x=0; x < m_image->width; x++)
        {
            //Pour chaque pixel, s'il est trop "au bord" :
            if (x<(proximity-1)/2 || x>(m_image->width - 1 - (proximity-1)/2) ||
                y<(proximity-1)/2 || y>(m_image->height -  1 - (proximity-1)/2))
            {
                //Dans ce cas on recopie simplement le pixel
                cvSet2D(imgSmooth, y, x, cvGet2D(m_image, y, x));
            }
            //sinon on applique la médiane au pixel par rapport à son entourage (voisinage*voisinage)
            else
            {
                //On centre le voisinage sur le pixel en cours
                roi.x= x - (proximity-1)/2;
                roi.y= y - (proximity-1)/2;
 
                //On initialise la région d'intérêt
                cvSetImageROI(m_image, roi);
                //Cette fois on parcourt juste la zone Roi (le voisinage) pour récupérer les valeurs dans un tableau
                for(int j=0; j < proximity; j++)
                {
                    for(int i=0; i<proximity; i++)
                    {
                        //application de la médiane sur le pixel
                        pixel = cvGet2D(m_image, j, i);
                        neighbour[i*proximity + j] = pixel.val[0];
                    }
                }
 
                //On relâche la région d'intérêt
                cvResetImageROI(m_image);
                //On classe les valeurs dans l'ordre croissant  sort(v_min, v_max)
                sort( neighbour.begin(), neighbour.end());
                //On choisit la valeur médiane
                pixel.val[0] = neighbour[(proximity*proximity-1)/2];
                //On la remplace dans l'image de destination
                cvSet2D(imgSmooth, y, x, pixel);
            }
        }
    }
 
    setImage(imgSmooth);
 
}
 
void ImageMod::setImage(IplImage*& imageToGet)
{
    cvReleaseImage(&m_image);
    m_image=cvCloneImage(imageToGet);
    cvReleaseImage(&imageToGet);
}
 
//vérifier l'origine de l'image
int ImageMod::origin(IplImage*& img)
{
 
    //Si l'origine n'est pas en haut à gauche, il faut la corriger
    int flip=0;
    if(img->origin!=IPL_ORIGIN_TL)
    {
        flip=CV_CVTIMG_FLIP;
    }
    return flip;
}

Informations données par le débugger : segmentation fault in function ntdll!RtlEqualLuid() (C:\Windows\system32\ntdll.dll)