[OpenCV] Affichage d'images

Bonjour,

Je développe une application de tri en ligne par analyse d'image couleur.
Environnement Ubuntu 14.04*; wxWidgets -3.0.2*; Opencv 3.0.0*; pylon 4.0
sous Eclipse

Depuis l'IHM, je lance un thread avec wxThread (wxWidgets 3.0). Dans ce thread il y a acquisition et traitement des images (60 images /s) en G Ethernet et pas mal de calcul.

Lorsque j'essaye d'afficher depuis le thread avec imshow d'opencv cela plante.

Question

Est-il correcte d'afficher des images depuis un thread et et si non pourquoi*?

Est-il possible de faire cet affichage en utilisant soit une autre bibliothèque pour le thread (ici wxthread), soit pour l'affichage (ici openCV imshow).

Par avance merci

Bonjour.

Citation:

Envoyé par boutten

Est-il correcte d'afficher des images depuis un thread et et si non pourquoi*?

Non : il ne faut surtout pas le faire.
En règle générale, il ne faut surtout pas toucher aux éléments de l'interface depuis un thread secondaire.
La solution est par exemple de stocker l'image à afficher de façon à ce qu'elle soit accessible depuis le thread principale, et poster un événement à la fenêtre pour qu'elle mette à jour l'affichage.

Il faut bien entendu penser à protéger la zone mémoire dans laquelle sera stockée l'image, pour que le thread secondaire n'écrive pas dedans lorsque le thread principal est en train de lire (voir l'exemple wxWidgets concernant les threads, et l'utilisation de wxCriticalSectionLocker).

@+
Xav'

affichage d'images avec OpenCV depuis un thread wxWidget

Bonjour,

voilà où j'en suis arrivé.
J'ai trois classes :
une classe IHM_Commande qui :
lance le thread d'acquisition et de traitement,
avec un timer cherche les images dans la classe stockage et les affiche.

Une classe Acquisition_Thread qui réalise l’acquisition et le traitement des images et les passe à la classe stockage

Une classe Stockage_Image qui stocke les images et les met à disposition de l'IHM_Commande c'est la classe stockage qui contient les Mutexs.

Les mutexs sont ils bien placés ?

Le programme est stable et l'affichage ne semble pas perturber les calculs. Maintenant il faut pousser les vitesses et augmenter le nombre de thread (3) pour voir comment cela se comporte au niveau des calculs. Normalement cela ne doit pas interférer…..

IHM_Commande.h

Code:

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
 
 
#include "wx/wx.h"
#include "wx/wxprec.h"
 
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
 
#include <Stockage_Image.h>
 
#include <Acquisition_Thread.h>
 
using namespace cv ;
 
class IHM_Commande: public wxFrame {
public:
	IHM_Commande(const wxString& title,
			CaracExpThread *pCaracExpThread_);
 
	~IHM_Commande();
 
	void AffichageCamera(wxCommandEvent& event);
	void Quitter(wxCommandEvent& event);
	void ActionTimer(wxTimerEvent& event);
 
protected:
 
	void Create_IHM_Commande(const wxString& title);
 
private:
	Stockage_Image * pStockage_Image ;
 	Acquisition_Thread *pAcquisition_Thread ;
	wxTimer* pTimerImage ;
	cv::Mat RGBDest ;
    DECLARE_EVENT_TABLE()
};

IHM_Commande.cpp

Code:

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
 
 
#include "IHM_Commande.h"
 
#define ID_AFFICHAGE_IMAGE              10101
#define ID_QUITTER                     	10103
#define ID_TIMER            			10104
 
IHM_Commande::IHM_Commande(const wxString& title,
		Stockage_Image *pStockage_Image_)
: wxFrame(NULL, wxID_ANY, title,  wxPoint(0,0),wxDefaultSize, wxDEFAULT_FRAME_STYLE)
{
	pStockage_Image = pStockage_Image_ ;
 
	pAcquisiotn = NULL ;
	pTimerImage = new wxTimer(this,ID_TIMER);
 
	Create_Thread(title);
}
 
IHM_Commande::~IHM_Commande() {
	// TODO Auto-generated destructor stub
}
 
BEGIN_EVENT_TABLE(IHM_Commande, wxFrame)
	EVT_BUTTON(ID_AFFICHAGE_IMAGE,IHM_Commande::AffichageCamera)
	EVT_BUTTON(ID_QUITTER, IHM_Commande::Quitter)
	EVT_TIMER(ID_TIMER, IHM_Commande::ActionTimer )
END_EVENT_TABLE()
 
void IHM_Commande::Create_IHM_Commande(const wxString &title) {
	// TODO Auto-generated destructor stub
	wxStaticText *pTXT_Vide1 = new wxStaticText(this, -1, _(""),wxDefaultPosition,wxDefaultSize);
 
	wxButton *pButtonAffichageCamera = new wxButton(this, ID_AFFICHAGE_IMAGE,
	_("Affichage Vision Camera"));
	wxButton *pButtonQuitter = new wxButton(this, ID_QUITTER,
	_("Quitter"));
 
	wxFlexGridSizer *pFGridSizerCadreCommande = new wxFlexGridSizer(2, 2, 0, 0);
	this->SetSizer(pFGridSizerCadreCommande);
 
	pFGridSizerCadreCommande->Add(pButtonAffichageCamera, 1, wxALIGN_CENTER_HORIZONTAL|
			wxALIGN_CENTER_VERTICAL|wxALL,5) ;
 
	pFGridSizerCadreCommande->Add(pTXT_Vide1,1, wxALIGN_CENTER_HORIZONTAL|
			wxALIGN_CENTER_VERTICAL|wxALL, 1);
	pFGridSizerCadreCommande->Add(pButtonQuitter,1, wxALIGN_CENTER_HORIZONTAL|
			wxALIGN_CENTER_VERTICAL|wxALL,5) ;
 
	pFGridSizerCadreCommande->Fit(this);
	pFGridSizerCadreCommande->SetSizeHints(this);
}
 
void IHM_Commande::AffichageCamera(wxCommandEvent& event) {
 
	/* en multi thread */
	pAcquisition_Thread = new Acquisition_Thread(
			pStockage_Image);
	if (!pAcquisition_Thread->IsRunning()){
		wxMessageBox(_("Thread ne tourne pas encore "),
		_("Thread ne tourne pas encore"),
		wxOK|wxICON_INFORMATION,this);
		pAcquisition_Thread->Create();
		pAcquisition_Thread->Run();
		if (pAcquisition_Thread->IsRunning()){
			wxMessageBox(_("Thread tourne "),
			_("Thread tourne "),wxOK|wxICON_INFORMATION,this);
		}
	}
	else {
		wxMessageBox(_("Thread tourne deja"),
				_("Thread tourne deja "),wxOK|wxICON_INFORMATION,this);
	}
	sleep(2);
	pTimerImage->Start(10);
}
 
void IHM_Commande::Quitter(wxCommandEvent& event) {
	/* en multi thread */
 
	if(pAcquisition_Thread->IsRunning()){
		pAcquisition_Thread->Pause();
		pAcquisition_Thread->Delete();
		pTimerImage->Stop();
		delete pTimerImage ;
	}
 
	cout << " IHM_Commande::Quitter "<< endl;
	Close(TRUE);
}
 
void IHM_Commande::ActionTimer(wxTimerEvent& event)
{
	namedWindow("Image Camera ", CV_WINDOW_NORMAL );
	imshow("Image Camera ",pStockage_Image->get_Image_RGB());
}

Stockage_Image.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#include "wx/wx.h"
#include "wx/wxprec.h"
 
using namespace cv ;
 
class Stockage_Image {
public:
	Stockage_Image();
	~Stockage_Image();
 
private:
	cv::Mat m_Image_RGB ;
 
public:
	cv::Mat get_Image_RGB(void);
	void set_Image_RGB(cv::Mat m_Image_RGB_);
};

Stockage_Image.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <Stockage_Image.h>
 
Stockage_Image::Stockage_Image() {
}
 
Stockage_Image::~Stockage_Image() {
	// TODO Auto-generated destructor stub
}
 
cv::Mat Stockage_Image::get_Image_RGB(void)
{
	wxMutexGuiEnter();
	return m_Image_RGB ;
	wxMutexGuiLeave();
}
 
void Stockage_Image::set_Image_RGB(cv::Mat m_Image_RGB_)
{
	wxMutexGuiEnter();
	m_Image_RGB_.copyTo(m_Image_RGB);
	wxMutexGuiLeave();
}

Acquisition_Thread.h

Code:

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
#include "wx/wx.h"
#include <wx/thread.h>
 
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <sstream>
 
#include <sys/time.h>
 
using namespace cv ;
using namespace std;
 
class Acquisition_Thread: public wxThread
{
public:
 
	Acquisition_Thread(
			Stockage_Image *pStockage_Image_);
 
	~Acquisition_Thread();
 
	void* Entry();
 
    int VisionCameraIHM(void);
 
 
private :
	time_t now ;
	struct tm *Time ;
    Stockage_Image * pStockage_Image ;
	cv::Mat *pRGBDest ;
};

Acquisition_Thread.cpp

Code:

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
#include "Acquisition_Thread.h"
 
 
Acquisition_Thread::Acquisition_Thread(
		Stockage_Image *pStockage_Image_
 
		) {
	// TODO Auto-generated constructor stub
 
	now = time(NULL) ;
	Time = NULL ;
 
    pStockage_Image = pStockage_Image_ ;
 
	cv::Mat *pRGBDest ;
}
 
Acquisition_Thread::~Acquisition_Thread() {
	// TODO Auto-generated destructor stub
}
 
void* Acquisition_Thread::Entry(){
	int i ;
	i = VisionCameraIHM();
}
 
int Acquisition_Thread::VisionCameraIHM(void){
 
 
/*Acquisition et traitement des image*/
 
		pStockage_Image->set_Image_RGB(*pRGBDest);
 
 
/*Acquisiiotn et traitement des images */
 
		delete pRGBDest ;
	return 1;
}