Bonjour,

j'essaie de créer un programme visant à afficher le flux vidéo de ma webcam sous linux (afin de faire un traitement d'images sur ce flux par la suite). J'ai trouvé sur le net le code suivant qui utilise QT4 et libopencv.

Voici le header, IplImageWidget.h" :

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
 
#ifndef IPLIMAGE_WIDGET
#define IPLIMAGE_WIDGET
 
#include <QWidget>
#include "cv.h"
 
 
struct IplImageWidgetData;
class IplImageWidget : public QWidget
{
    Q_OBJECT
public:
    IplImageWidget(QWidget* parent = 0, Qt::WFlags fl = 0 );
    ~IplImageWidget();
 
    void setIplImage(IplImage*);
 
protected:
    void paintEvent(QPaintEvent*);
    void initImages(IplImage*);
 
private:
    IplImageWidgetData* d;
};
 
#endif
Le .cpp, IplImageWidget.cpp

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
#include "IplImageWidget.h"
 
#include <QImage>
#include <QPainter>
#include <QMutexLocker>
#include <QMutex>
 
 
struct IplImageWidgetData
{
    IplImageWidgetData() : iplImage(NULL), mutex(QMutex::Recursive) {};
 
    IplImage* iplImage;
    QImage qtImage;
    QMutex mutex;
};
 
IplImageWidget::IplImageWidget(QWidget* parent, Qt::WFlags fl)
: QWidget(parent, fl)
{
    d = new IplImageWidgetData;
}
 
IplImageWidget::~IplImageWidget()
{
    delete d;
}
 
void IplImageWidget::initImages(IplImage* image)
{
    try
    {
        QMutexLocker locker(&d->mutex);
        if(d->iplImage)
        {
            cvReleaseImage(&d->iplImage);
            d->iplImage = NULL;
        }
 
        d->iplImage = cvCreateImage(cvSize(image->width, image->height), IPL_DEPTH_8U, 3);
        if(!d->iplImage)
            throw QString("Error : cvCreateImage() return null.\n");
 
        // feed into QImage  
        uchar *cv = (uchar*) (d->iplImage->imageData);
        d->qtImage = QImage(cv, d->iplImage->width, d->iplImage->height, d->iplImage->widthStep, QImage::Format_RGB888);  
 
        // Resize the widget
        resize(d->iplImage->width, d->iplImage->height);
    }
    catch(QString msg)
    {
        msg += "IplImageWidget::initImages return error\n";
        qWarning(msg.toLatin1().data());
        return;
    }
    catch(...)
    {
        QString msg("IplImageWidget::initImages return error\n");
        qWarning(msg.toLatin1().data());
        return;
    }
}
void IplImageWidget::setIplImage(IplImage* image)
{
    try
    {
    if(!image)
        return;
 
    d->mutex.lock();
 
    if(!d->iplImage)
    {
        initImages(image);
    }
 
    // IF the image size changes
    if(d->iplImage)
        if(image->width != d->iplImage->width || image->height != d->iplImage->height)
        {
            initImages(image);
        }
 
    // convert image to RGB format  
    switch(image->nChannels)
    {
    case 1: 
        cvCvtColor(image, d->iplImage, CV_GRAY2RGB);
        break;
    case 3: 
        cvCvtColor(image, d->iplImage, CV_BGR2RGB);
        break;
    case 4:
        cvCvtColor(image, d->iplImage, CV_BGRA2RGB);
        break;
    }
    d->mutex.unlock();
 
    // Post a repaint
    update();
 
    }
    catch(QString msg)
    {
        d->mutex.unlock();
        msg += "IplImageWidget::setIplImage return error\n";
        qWarning(msg.toLatin1().data());
        return;
    }
    catch(...)
    {
        d->mutex.unlock();
        QString msg("IplImageWidget::setIplImage return error\n");
        qWarning(msg.toLatin1().data());
        return;
    }
}
 
void IplImageWidget::paintEvent(QPaintEvent*)
{
    QPainter painter(this);
    painter.drawImage(d->qtImage.rect(), d->qtImage);
}
Tout compile bien, mais à l'exécution, la fenetre qui s'affiche est vide. J'aimerais savoir s'il faut que je précise dans le code que l'on doit accéder au device de ma webcam qui est sur /dev/vide0, du genre :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
file_descriptor = open(/dev/video0,....
Je ne sais pas si la méthode "drawImage(d->qtImage.rect(), d->qtImage)" dans paintEvent accède implicitement au device de la webcam.

Merci d'avance pour votre aide.