Discussion :

[killshout]

Bonjour,

A partir d'une image je fais des calculs de moyenne de couleur pour les trois canal (R,G,B) sur une fenêtre réduite (8x8) pour ensuite réduire cette fenêtre à une simple couleur (je peux vous montrer le code)
Ceci ce passe dans une fonction.
Sauf que cette fonction plante quand je fais tourner mon programme.

Si ce n'était que ça j'aurais pu le debugger volontiers.

Mais j'ai remarqué que la fonction marchait en ajoutant ceci juste avant d’appeler la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    printf("row = %d\n",image.rows);
    printf("col = %d\n",image.cols);

"image" est la matrice sur la quelle je travail (

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Mat image

).

Pourquoi diable un "printf" fait-il marchait ma fonction ?

Si vous avez la réponse je suis fort intéressé.

Merci à vous.

[snowpy]

Peux tu nous en dire un peu plus sur ton code ? (le poster par exemple ^^)

[Picard2200]

Bonjour,

Les symptômes que tu donnes indiquent clairement une fuite mémoire quelque part.

Si tu es sous Linux, valgrind devrait pouvoir t'aider.

[killshout]

Voici le code :

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
    int red_mean = 0,green_mean = 0,blue_mean = 0, block_counter = 0;
    Point position = Point(0,0), counter = Point(0,0);
 
    //In the image
    do
    {
        do
        {
            //In the window
            do
            {
                do
                {
                    if((position.y + counter.y) <= image.rows && (position.x + counter.x) <= image.cols)
                    {
                        blue_mean += image.at<Vec3b>(position.y + counter.y,position.x + counter.x)[0];
                        green_mean += image.at<Vec3b>(position.y + counter.y,position.x + counter.x)[1];
                        red_mean += image.at<Vec3b>(position.y + counter.y,position.x + counter.x)[2];
 
                        block_counter++;
                    }
 
                    counter.x++;
 
                }while(counter.x < window_size);
 
                counter.x = 0;
 
                counter.y++;
 
            }while(counter.y < window_size);
 
            counter.y = 0;
 
            //Average is done for the window of size window_size*window_size
            //So know we set all the window to the mean value
            blue_mean /= block_counter;
            green_mean /= block_counter;
            red_mean /= block_counter;
 
            block_counter = 0;
 
            for(int y = position.y; y < position.y + window_size; y++)
            {
                for(int x = position.x; x < position.x + window_size; x++)
                {
                    if(y <= image.rows && x <= image.cols)
                    {
                        image.at<Vec3b>(y,x)[0] = blue_mean;
                        image.at<Vec3b>(y,x)[1] = green_mean;
                        image.at<Vec3b>(y,x)[2] = red_mean;
                    }
                }
            }
 
            position.x += window_size;
 
        }while(position.x < image.cols);
 
        position.x = 0;
        position.y += window_size;
 
    }while(position.y < image.rows);

Mais même s'il y a une fuite mémoire pourquoi cela fonctionne t-il quand j'utilie un printf avant ?

[Al_th]

Ca fait un bon moment que j'ai entendu ca, mais il me semble qu'un de mes profs de sécurité info nous avait parlé de ce genre de "résolution" mystérieuse de bugs et nous avait expliqué, si je ne m'abuse, que l'influence de l'appel d'une fonction telle que printf sur la pile d'appel pouvait "corriger" certains bugs (ou du moins les cacher, ils existent toujours).

Quelqu'un de plus compétent pourra sans doute être plus clair que moi, mais il me semble que ça tourne autour de cela.