[Visual C++ - VS 2008]Gestione multithreads - uso BeginInvoke

[lordjoseph]

Ciao a tutti!
Ho un problema da proporvi!
Sto lavorando ad un progetto in Visual C++ (con VS 2008 - progetto di tipo windows form application) e per necessità ho dovuto creare un thread che mi aggiornasse in un ciclo "infinito" la proprietà Image di una picture box creata però nel thread principale.
Il problema che mi si è posto è stato: come fare a modificare la proprietà di un oggetto, in questo caso della picturebox, da un thread diverso da quello in cui è stato generato?
La soluzione trovata è stata usare una BeginInvoke che chimasse un delegato.

private:delegate void MyDelegate(IplImage *view );
void video(IplImage *view){
		 
		 if(videobox->InvokeRequired){
			 videobox->BeginInvoke(gcnew MyDelegate(this,&Form1::InvokeMethod),view); //non posso passare view(non è un Object^)
		 }
		 else{
			 this->videobox->Image=view;

		 }
	 
	 }

	 void InvokeMethod(IplImage *view )
	 {

		 videobox->Image=view;
	 }

Adesso il problema è : come faccio a passare il parametro view di tipo IplImage* al metodo InvokeMethod?(come scritto su non funziona)
Il BeginInvoke permette il passaggio di un array di Object^ e non so come fare per passare sto view ...

[giangian2]

ciao,
al tuo delegate invece di passare direttamente il tuo oggetto IplImage, ti crei una tua classe che deriva da EventArgs e metti una proprietà con un puntatore al tuo oggetto IplImage.

public ref class MyEventArgs : EventArgs
{
public:
	MyEventArgs(IplImage * pView)
	{
		_pView = pView;
	}

	property IplImage * View
	{
		IplImage * get() { return _pView; }
	}
private:
	IplImage * _pView;
};

a questo punto il tuo delegate non prende più un puntatore ad IplImage come argomento, ma bensì un oggetto MyEventArgs

private:delegate void MyDelegate(MyEventArgs ^ args);

nella BeginInvoke non passi più il puntatore all'oggetto IplImage, ma un array di object in cui ci sarà un solo oggetto che è l'instanza della classe MyEventArgs.

Spero di essere stato chiaro :-)
ciao ciao
Marco

[lordjoseph]

Grazie!!!
In effetti sarei dovuto arrivarci anche da solo ma è da poco che uso le classi e soprattutto visual c++
Il codice modificato è il seguente :

private:delegate void MyDelegate(MyEventArgs^ vista);

	 void video(IplImage *view){
		 MyEventArgs^ vista = gcnew MyEventArgs(view);
		 array<Object^>^myArray = gcnew array<Object^>(1);
		 myArray[0]=vista;
		 
		 if(videobox->InvokeRequired)
                     {
			 videobox->BeginInvoke(gcnew MyDelegate(this,&Form1::InvokeMethod),vista);
		     }
		else{
			 this->videobox->Image=(gcnew System::Drawing::Bitmap(view->width,view->height,view->widthStep,System::Drawing::Imaging::PixelFormat::Format24bppRgb,(System::IntPtr)view->imageData)); 
			

		     }
	 
	 }

	 void InvokeMethod(MyEventArgs^ vista)
	 {
	         IplImage *view;
		 view=vista->View;
		 videobox->Image=(gcnew System::Drawing::Bitmap(view->width,view->height,view->widthStep,System::Drawing::Imaging::PixelFormat::Format24bppRgb,(System::IntPtr)view->imageData)); 
	 }

Ti devo fare alcune domande :
1)Perchè se non metto una sleep dopo la chiamata a video(view); del thread, l'applicazione mi fornisce la seguente eccezione "System.Reflection.TargetInvocationException" ?
2)Prima di usare l'Invoke modificavo la proprietà Image della picturebox direttamente all'interno del thread creato da me (Non quello dove è stato creato l'oggetto) e mettendo una Sleep dopo videobox->Image=(gcnew System:rawing::Bitmap... il programma funzionava lo stesso.
Ho notato però che il video visualizzato nella picturebox (sequenza di immagini) andava a scatti e quindi pensando di aver utilizzato un metodo errato ne ho cercato uno che consentisse di modificare la proprietà di un oggetto creato in un thread diverso degno di un programmatore arrivando così all' Invoke di un delegato.Potevo lasciare la vecchia soluzione o è comunque meglio usare un delegato?
3)Dubbi : qual è la differenza tra Invoke e BeginInvoke ?
Ho letto che Invoke è un metodo sincrono e BeginInvoke asincrono ma mi sai dare qualche spiegazione in più?

[giangian2]

ciao

1)Perchè se non metto una sleep dopo la chiamata a video(view); del thread, l'applicazione mi fornisce la seguente eccezione "System.Reflection.TargetInvocationException" ?

prova a postare il codice.

2)Prima di usare l'Invoke modificavo la proprietà Image della picturebox direttamente all'interno del thread creato da me (Non quello dove è stato creato l'oggetto) e mettendo una Sleep dopo videobox->Image=(gcnew System:rawing::Bitmap... il programma funzionava lo stesso.
Ho notato però che il video visualizzato nella picturebox (sequenza di immagini) andava a scatti e quindi pensando di aver utilizzato un metodo errato ne ho cercato uno che consentisse di modificare la proprietà di un oggetto creato in un thread diverso degno di un programmatore arrivando così all' Invoke di un delegato.Potevo lasciare la vecchia soluzione o è comunque meglio usare un delegato?

va bene la nuova implementazione con il delegato, la grafica va sempre modificata dal thread principale che l'ha creata. Chiamando la Invoke o BeginInvoke di un delegato il codice viene poi eseguito nel thread principale.

3)Dubbi : qual è la differenza tra Invoke e BeginInvoke ?
Ho letto che Invoke è un metodo sincrono e BeginInvoke asincrono ma mi sai dare qualche spiegazione in più?

come hai già detto tu il metodo Invoke è sincrono mentre il metodo BeginInvoke è asincrono. La differenza è che chiamando il metodo Invoke il codice chiamante resta fermo finchè viene eseguito il codice del delegato e poi continua, mentre con il metodo BeginInvoke il codice chiamante procede l'esecuzione del codice.

[lordjoseph]

Avrò sbagliato sicuramente qualcosa col thread dato che non avevo mai usato il multithreading prima...
La funzione che poi avvio come thread è definita all'interno del file Form1.h (il form principale del progetto dal quale attraverso un tasto creo e avvio il thread), è giusto fare così?
Ti posto il programma con il codice che fornisce l'errore (ho cancellato un po' di roba per renderlo più leggibile, inoltre sono state usate funzioni di librerie utili per la cattura video).

using namespace System::Threading;
using namespace System::Runtime::InteropServices;
#pragma once

bool flag,start,sospeso;

public ref class MyEventArgs : EventArgs
{
public:
	MyEventArgs(IplImage * pView)
	{
		_pView = pView;
	}

	property IplImage * View
	{
		IplImage * get() { return _pView; }
	}
private:
	IplImage * _pView;
};


namespace NomeProgetto{
	using namespace System;
	using namespace System::ComponentModel;
	using namespace System::Collections;
	using namespace System::Windows::Forms;
	using namespace System::Data;
	using namespace System::Drawing;
	using namespace System::IO;


	public ref class Form1 : public System::Windows::Forms::Form
	{
			
	public:
		Form1(void)
		{
			InitializeComponent();
			//
			//TODO: aggiungere qui il codice del costruttore.
			//
			//Varie inizializzazione di variabili
			CheckForIllegalCrossThreadCalls=false;			
			flag=0;
			start=0;
			sospeso=0;											
		}

	protected:
		/// <summary>
		/// Liberare le risorse in uso.
		/// </summary>
		~Form1()
		{
			if (components)
			{
				delete components;
			}
		}


	private: System::Windows::Forms::Button^  button1;
	private: System::Windows::Forms::PictureBox^  videobox;
	private: System::Windows::Forms::Button^  esci;
	private: Thread^ capThread;
	  
	protected: 

	private:
		/// <summary>
		/// Variabile di progettazione necessaria.
		/// </summary>
		System::ComponentModel::Container ^components;

#pragma region Windows Form Designer generated code
		/// <summary>
		/// Metodo necessario per il supporto della finestra di progettazione. Non modificare
		/// il contenuto del metodo con l'editor di codice.
		/// </summary>
		void InitializeComponent(void)
		{
			this->button1 = (gcnew System::Windows::Forms::Button());
			this->videobox = (gcnew System::Windows::Forms::PictureBox());
			this->esci = (gcnew System::Windows::Forms::Button());
			(cli::safe_cast<System::ComponentModel::ISupportInitialize^  >(this->videobox))->BeginInit();
			this->SuspendLayout();
			// 
			// button1
			// 
			this->button1->Location = System::Drawing::Point(50, 452);
			this->button1->Name = L"button1";
			this->button1->Size = System::Drawing::Size(94, 44);
			this->button1->TabIndex = 2;
			this->button1->Text = L"START";
			this->button1->UseVisualStyleBackColor = true;
			this->button1->Click += gcnew System::EventHandler(this, &Form1::button1_Click);
			// 
			// videobox
			// 
			this->videobox->BackColor = System::Drawing::SystemColors::ControlDark;
			this->videobox->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
			this->videobox->Cursor = System::Windows::Forms::Cursors::Cross;
			this->videobox->Location = System::Drawing::Point(32, 52);
			this->videobox->Name = L"videobox";
			this->videobox->Size = System::Drawing::Size(428, 347);
			this->videobox->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage;
			this->videobox->TabIndex = 0;
			this->videobox->TabStop = false;
			// 
			// esci
			// 
			this->esci->Location = System::Drawing::Point(559, 452);
			this->esci->Name = L"esci";
			this->esci->Size = System::Drawing::Size(94, 44);
			this->esci->TabIndex = 3;
			this->esci->Text = L"EXIT";
			this->esci->UseVisualStyleBackColor = true;
			this->esci->Click += gcnew System::EventHandler(this, &Form1::esci_Click);
			// 
			
			
			// 
			// Form1
			// 
			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
			this->ClientSize = System::Drawing::Size(703, 526);
			this->Controls->Add(this->esci);
			this->Controls->Add(this->videobox);
			this->Controls->Add(this->button1);
			this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
			this->MaximizeBox = false;
			this->Name = L"Form1";
			this->Text = L"Camera";
			(cli::safe_cast<System::ComponentModel::ISupportInitialize^  >(this->videobox))->EndInit();
			this->ResumeLayout(false);
			this->PerformLayout();

		}
#pragma endregion

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
			Graphics ^ g;
			// Sets g to a graphics object representing the drawing surface of the
			// control or form g is a member of.
			g = this->CreateGraphics();
			//Disegna il contorno
			// Crea una penna.
			Pen^ blackPen = gcnew Pen( Color::Black,3.0f );
			// Disegna l'ellisse
			g->DrawEllipse( blackPen, 480,50,25,25 );
			SolidBrush^ redBrush = gcnew SolidBrush( Color::Red );
			// Riempimento ellisse
			g->FillEllipse( redBrush, 480, 50, 25, 25 );
			
			flag=0;
			start=1;
			this->capThread =gcnew Thread(gcnew ThreadStart(this,&Form1::ThreadProcSafe));
			this->capThread->IsBackground=false;
			this->capThread->Start();

		}//fine evento pulsante


//Funzione Thread
public:
    void ThreadProcSafe()
    {
	CvCapture* capture = 0;
    capture = cvCreateCameraCapture(0);
    if( !capture ) return;    
	//Ciclo For di Calibrazione e cattura immagine
	for(;;)
    {	
        IplImage *view = 0, *view_gray = 0;        
		 if( capture )
        {
            IplImage* view0 = cvQueryFrame( capture );
            if( view0 )
            {
                view = cvCreateImage( cvGetSize(view0), IPL_DEPTH_8U, view0->nChannels );
                if( view0->origin == IPL_ORIGIN_BL )
                    cvFlip( view0, view, 0 );
                else
                    cvCopy( view0, view );
            }
        }
        
		//Visualizza video nella picturebox
		video(view);
		//Thread::Sleep(30); // se non metto questa riga segnala 'System.Reflection.TargetInvocationException'

		//Rilascio risorse
		if( !view )
            break;
        cvReleaseImage( &view );
		if(flag==1) break; //Flag di uscita dal Thread		
    }
    if( capture )
        cvReleaseCapture( &capture );
    	
	 }
	//Fine Funzione Thread	 

	private:delegate void MyDelegate(MyEventArgs^ vista);

	 void video(IplImage *view){
		 MyEventArgs^ vista = gcnew MyEventArgs(view);
		 array<Object^>^myArray = gcnew array<Object^>(1);
		 myArray[0]=vista;
		 
		 if(videobox->InvokeRequired){
			 videobox->BeginInvoke(gcnew MyDelegate(this,&Form1::InvokeMethod),vista);
		 }
		 else{
			 this->videobox->Image=(gcnew System::Drawing::Bitmap(view->width,view->height,view->widthStep,System::Drawing::Imaging::PixelFormat::Format24bppRgb,(System::IntPtr)view->imageData)); 			 
		 }
	 
	 }

	 void InvokeMethod(MyEventArgs^ vista)
	 {
		 IplImage *view;
		 view=vista->View;
		 videobox->Image=(gcnew System::Drawing::Bitmap(view->width,view->height,view->widthStep,System::Drawing::Imaging::PixelFormat::Format24bppRgb,(System::IntPtr)view->imageData)); 
	 }
	 
//Pulsante Esci
private: System::Void esci_Click(System::Object^  sender, System::EventArgs^  e) {			 
			 flag=1; //Flag che permette la terminazione del Thread di cattura
			 Application::Exit();			 
	 }
 //Fine Pulsante Esci
};

}

[giangian2]

Ciao.
Prova a sostituire la chiamata al metodo BeginInvoke (asincrono) con Ivoke (sincrono).
Premetto che non conosco OpenCV, ma dal tuo codice il problema potrebbe essere che venga rilasciata l'immagine 'view' prima che il thread principale aggiorni la picturebox.

cvReleaseImage( &view );

Mettendo uno Sleep il thread principale riesce ad eseguire il codice ed aggiornare la picturebox prima che venga rilasciata l'immagine 'view'.

ciao ciao

[lordjoseph]

Non va!
Mi sa che la sleep è necessaria per limitare il numero di frame al secondo...
Tra l'altro mettendo la Invoke la picturebox diventa bianca e se provo a spostare il form viene lanciata la seguente eccezione :

Eccezione non gestita di tipo 'System.AccessViolationException' in System.Drawing.dll

Informazioni aggiuntive: Tentativo di lettura o scrittura della memoria protetta. Spesso questa condizione indica che altre parti della memoria sono danneggiate.

Questa stessa eccezione mi viene lanciata anche quando spostando la finestra "al di fuori dello schermo" la riporto all'interno (probabilmente perchè viene fatto un refresh del form? )
Nel programma "funzionante" (con la sleep) ho cercato di evitare l'errore qui sopra scritto impostando da programma una suspend e una resume del thread quando opportuno.