Discussion :

[Jim_Nastiq]

salut,

Pour la detection de mouvement sur video il est possible d'utiliser une image de reference(image de fond) qui permet de servir de comparaison aux autres images , via la soustraction(aparement largement utilisée) cependant,je viens de me rendre compte qu'il y a une zone d'ombre pour moi a ce sujet en effet mes images etant codée en 8 bits(0 à 255) si un pixel X sur l'image de reference vaut par exemple 100 et que ce meme pixel X est supérieur a 100 sur l'image traitée alors ma soustraction me donnera toujours 0(equivalent a aucun mouvement ,ce qui est faux)

alors je me demande comment cela fonctionne!est ce qu'en fait les pixels sont codés sur 16 bits(-256 a 255)

parce qu'en tout cas sous OpenCV j'ai des problemes qui semblent venir de cela(objet en mouvement plus clair que le fond)

merci de votre aide

[souviron34]

salut,
alors je me demande comment cela fonctionne!est ce qu'en fait les pixels sont codés sur 16 bits(-256 a 255)

plusieurs manières de faire, mais ce n'est pas que les pixels sont codés sur un nombre de bits différents.

Pour le calcul on peut utiliser une variable de stockage double, puis on re-normalise..., ou on le fait au vol...

[Jim_Nastiq]

ok ! merci pour ta reponse! mais sous OpenCV(si tu connais) la soustraction est une fonction deja faites je l'utilise simplement en faisant son appel(cvSub) je pense que intel a prevu le coup tout de meme... je vais voir d'ou peut venir le probleme!
encore merci

[progfou]

Tu parles de la DFD (Difference entre Frames) ?
Si c'est le cas, ce n'est plus beaucoup utilisé, aujourd'hui, on se sert de block matching, c'est à dire qu'on cherche, dans l'image à prédire, le vecteur de mouvement tel que, pour un bloc donné dans l'image de référence, la correspondance avec le bloc dans l'image à prédire soit la meilleure possible.

Les vecteurs de mouvement sont codés entre +-15 pixels en général, et l'on code de manière spécifique (au niveau du codeur entropique). Mais en général dans le code, c'est un simple char (signé) qui est utilisé.

[Jim_Nastiq]

ok, merci! t'aurais des liens ou des exemples de cet algo par hasard?

je vais voir ce que je trouve sur le sujet...

[diamss]

Si ça peut en aider certains, je travail sur un flux MJPEG venant d'une caméra Axis M1011 actuellement. J'ai donc utilisé JOpenCV que j'ai modifier suivant mes besoins pour faire de la détection de mouvements.

Mon code prend 2 frames, il passe les frames en niveaux de gris, fait un filtre median pour enlever le bruit puis passe en binaire (noir et blanc) avec un threshold. Pour finir il suffit de soustraire les 2 images pour avoir le mouvement en blanc sur fond noir.
Je garde la dernière frame en niveaux de gris que j'additionne au mouvement, ce qui me donne une image avec le mouvement superposé.



J'ai pas encore réussi à enlever la barbe avec OpenCV

Voici le code Java qui fait la différence entre 2 frames :

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
 
public void compare(BufferedImage image1, BufferedImage image2) throws IOException {
 
        // Temporary grayscale image
        JIplImage temp = null;
        // Threshod parameters
        int floor = 60;
        int max   = 255;
 
        // Original colored image
        JIplImage src1 = new JIplImage(image1);
        // Grayscale image
        JIplImage dst1 = new JIplImage(image1.getWidth(), image1.getHeight(), 8, 1);
 
        // Processing
        JOpenCV.cvCvtColor(src1, dst1, 6);
        temp = new JIplImage(image1.getWidth(), image1.getHeight(), 8, 1);
        JOpenCV.cvSmooth(dst1, temp, JOpenCV.MEDIAN, 5, 0, 0, 0);
        JOpenCV.cvThreshold(temp, dst1, floor, max, 0);
 
        // Original colored image
        JIplImage src2 = new JIplImage(image2);
        // Grayscale image
        JIplImage dst2 = new JIplImage(image2.getWidth(), image2.getHeight(), 8, 1);
        JIplImage gray = new JIplImage(image2.getWidth(), image2.getHeight(), 8, 1);
 
        // Processing
        JOpenCV.cvCvtColor(src2, gray, 6);
        temp = new JIplImage(image2.getWidth(), image2.getHeight(), 8, 1);
        JOpenCV.cvSmooth(gray, temp, JOpenCV.MEDIAN, 5, 0, 0, 0);
        JOpenCV.cvThreshold(temp, dst2, floor, max, 0);
 
        // Image substraction
        JIplImage dst = new JIplImage(image2.getWidth(), image2.getHeight(), 8, 1);
 
        JOpenCV.cvSub(dst2, dst1, temp, 0);
        JOpenCV.cvSmooth(temp, dst1, JOpenCV.MEDIAN, 13, 0, 0, 0);
 
        // Image addition
        JOpenCV.cvAdd(dst1, gray, dst, 0);
 
        // Display
        imgSrc1.setImage(image1);
        imgSrc2.setImage(dst2.getBufferedImage());
        imgDst.setImage(dst.getBufferedImage());
 
        // Free memory
        dst.deallocate();
        dst1.deallocate();
        dst2.deallocate();
        gray.deallocate();
        src1.deallocate();
        src2.deallocate();
        temp.deallocate();
    }

[3dsman]

soit A ton image de ref (fond) et B ton image a verifier, tu fait (A-B) + (B-A) vu que tes calculs sont clampés a 0 tu aura une image des differences (en positif et negatif) entre tes deux images