Discussion :

[deejay2221]

Bonjours.

Je suis en train de développer un programme qui fais des captures d'écrans et compare l'image avec l'ancienne.

Naturellement j'ai débuté en faisant une double boucle en passant chacun des pixels avec la fonction GetPixel() mais c'est extrèmement lent et ça rempli la mémoire de classes inutilement.

Mon Core 2 Duo 2.33 est au maximum pendant au moins 2 secondes pour chacune des images traité. C'est trop lent.

Quelqu'un aurait connaissance d'une façon plus rapide et moins exigeant pour le CPU?

Merci

[smyley]

Si tu enregistre l'image dans un MemoryStream et que tu calcules sont Hash, ça pourrai peut être servir de méthode plus rapide non ? (et si deux Hash sont égaux, tu reprends l'ancienne méthode pour être sur).

[tomlev]

Si tu enregistre l'image dans un MemoryStream et que tu calcules sont Hash, ça pourrai peut être servir de méthode plus rapide non ? (et si deux Hash sont égaux, tu reprends l'ancienne méthode pour être sur).

Je ne suis pas sûr que ça change grand chose aux perfs... dans un cas comme dans l'autre, on va quand même lire toutes les données des 2 images. Cela dit, la méthode GetPixel est réputée assez lente, donc ça vaut peut-être le coup d'essayer...

Par contre pour le coup des 2 hash égaux, je pense pas que ce soit une bonne idée. Dans la plupart des cas l'image va être identique (si on a touché à rien entre temps), donc l'ancienne méthode va être appelée quasiment à chaque fois. De toutes façons, la probabilité d'avoir une collision (même hash pour 2 images différentes) est infime, donc je pense que le test sur les hash est suffisant.

[smyley]

Par contre pour le coup des 2 hash égaux, je pense pas que ce soit une bonne idée. Dans la plupart des cas l'image va être identique (si on a touché à rien entre temps), donc l'ancienne méthode va être appelée quasiment à chaque fois. De toutes façons, la probabilité d'avoir une collision (même hash pour 2 images différentes) est infime, donc je pense que le test sur les hash est suffisant.

Non mais le truc aurait été qu'il trouve par malchance une collision et le programme ne fonctionnerai pas correctement et personne ne saurait pourquoi vu que c'est pas trop à ça qu'on pense en premier. Il faudrait quand même vérifier, peut être avec quelques pixels pris aux hasard par exemple car même si la probabilité est très petite, elle n'est pas nulle (d'ailleurs un hash en moyenne ne dépasse pas quelques octets alors allez voir le nombre de combinaisons possibles de bit dans le hash par rapport au nombre de combinaisons possibles de bit dans une image de 400 Ko )

[tomlev]

Une autre solution, si on est pas trop regardant sur la précision, serait de générer des miniatures des 2 images (Image.GetThumbnailImage) et de comparer ces miniatures. Ca irait nettement plus vite...

[neptune]

On parle ici de capture d'écran, donc d'image assez petite finalement, avec une résolution de 72 dpi. C'est vraiment pas énorme.

L'idée du hash est très bonne; c'est ce que je ferais. Mais tu peux continuer sur ta lancée en comparant les pixels, il y a moyen de contourner GetPixels via une méthode unsafe.

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
89
90
91
92
93
94
using System;
using System.Drawing;
using System.Drawing.Imaging;
 
namespace Image {
    public unsafe class FastBitmap {
 
        public struct PixelData {
            public byte blue;
            public byte green;
            public byte red;
        }
 
        Bitmap Subject;
        int SubjectWidth;
        BitmapData bitmapData = null;
        Byte* pBase = null;
 
        public FastBitmap(Bitmap SubjectBitmap) {
            this.Subject = SubjectBitmap;
            try {
                LockBitmap();
            } catch (Exception ex) {
                throw ex;
            }
 
        }
 
        public void Release() {
            try {
                UnlockBitmap();
            } catch (Exception ex) {
                throw ex;
            }
        }
 
        public Bitmap Bitmap {
            get {
                return Subject;
            }
        }
 
        public void SetPixel(int X, int Y, Color Colour) {
            try {
                PixelData* p = PixelAt(X, Y);
                p->red = Colour.R;
                p->green = Colour.G;
                p->blue = Colour.B;
            } catch (AccessViolationException ave) {
                throw (ave);
            } catch (Exception ex) {
                throw ex;
            }
        }
 
        public Color GetPixel(int X, int Y) {
            try {
                PixelData* p = PixelAt(X, Y);
                return Color.FromArgb((int)p->red, (int)p->green, (int)p->blue);
            } catch (AccessViolationException ave) {
                throw (ave);
            } catch (Exception ex) {
                throw ex;
            }
        }
 
        private void LockBitmap() {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = Subject.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
                (int)boundsF.Y,
                (int)boundsF.Width,
                (int)boundsF.Height);
 
            SubjectWidth = (int)boundsF.Width * sizeof(PixelData);
            if (SubjectWidth % 4 != 0) {
                SubjectWidth = 4 * (SubjectWidth / 4 + 1);
            }
 
            bitmapData = Subject.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            pBase = (Byte*)bitmapData.Scan0.ToPointer();
        }
 
        private PixelData* PixelAt(int x, int y) {
            return (PixelData*)(pBase + y * SubjectWidth + x * sizeof(PixelData));
        }
 
        private void UnlockBitmap() {
            Subject.UnlockBits(bitmapData);
            bitmapData = null;
            pBase = null;
        }
    }
}