Accéder au device /dev/video0

**fab13** · 17/11/2009, 09h43

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.

**atomicJo** · 17/11/2009, 11h24

salut,
a aucun moment il n'y a un un appel pour récupérer le flux de ta camera dans ton code, c'est un truc du genre grabcamera, regarde dans la doc d'openCV

**fab13** · 17/11/2009, 13h38

j'ai trouvé la méthode en question, c'est "cvCaptureFromCAM(0)". J'ai rajouté le code en gras dans void IplImageWidget::initImages(IplImage* image) :

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
void IplImageWidget::initImages(IplImage* image)
{
    try
    {
        QMutexLocker locker(&d->mutex);
	CvCapture* capture = cvCaptureFromCAM(0);
	d->iplImage=(IplImage*) capture;
	
        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;
    }
}

ça compile mais à l'exécution, toujours la fenêtre qui est vide.

le cast "d->iplImage=(IplImage*) capture " est correct me semble t-il, non ?

Voyez vous ce qui cloche ?

Merci.

**atomicJo** · 18/11/2009, 13h48

essayes ceci :

Code :

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

1
2
3
4
5
 
CvCapture* capture = cvCaptureFromCAM(0);
cvGrabFrame(capture);
d->iplImage = cvRetrieveFrame(capture);
cvSaveImage("test-image.bmp",d->iplImage);

tu verras si tu as bien récupéré le flux de ta camera et sauvegardé une image au moment de l'execution. Une fois cette étape accomplit tu pourras aller plus loin pour l'affichage du flux dans un QWidget, si tu veux du temps réel plusieurs moyens possibles (voir le sujet Qt récent "technique d'affichage vidéo" sur ce même forum)

Accéder au device /dev/video0

Qt

Discussions similaires

Partager

Partager