Programming Reference:VisualizationContainerDemo Signal Processing - Revision history

Mellinger: /* Implementation */

2023-06-14T16:48:57Z

Implementation

← Older revision		Revision as of 16:48, 14 June 2023
Line 16:		Line 16:

	==Implementation==		==Implementation==
	Each visualization window is implemented as a ''VisualizationObject'' that contains a ''Visualization'' and a ''Computation'' object. Whenever a new block of data arrives, computation is done for the individual window's pair of channels in the main thread. Then, the result is sent to the Operator window inside a ''GenericSignal'' object. As both computation effort and the amount of data is limited, and to keep the example code simple, no multithreading is involved in this demo. (For an example that involves multithreading, see [[Programming Reference:ComplexVisualizationDemo Signal Processing]].		Each visualization window is implemented as a ''VisualizationObject'' that contains a ''Visualization'' and a ''Computation'' object. Whenever a new block of data arrives, computation is done for the individual window's pair of channels in the main thread. Then, the result is sent to the Operator window inside a ''GenericSignal'' object. As both computation effort and the amount of data is limited, and to keep the example code simple, no multithreading is involved in this demo. (For an example that involves multithreading, see [[Programming Reference:ComplexVisualizationDemo Signal Processing]].)

	===Declaration of internal variables===		===Declaration of internal variables===

Mellinger: /* See also */

2023-06-14T16:28:51Z

Mellinger: /* Parameters */

2023-06-14T16:28:12Z

Parameters

@@ Line 142: / Line 142: @@
+}
 </syntaxhighlight>
 ==See also==

Mellinger: /* BCI2000 GraphDisplay vs. QPainter rendering */

2023-06-14T16:26:43Z

BCI2000 GraphDisplay vs. QPainter rendering

@@ Line 142: / Line 142: @@
+}
 </syntaxhighlight>
 ==Parameters==

Mellinger: /* StartRun() and StopRun() */

2023-06-14T16:26:18Z

StartRun() and StopRun()

← Older revision		Revision as of 16:26, 14 June 2023
Line 127:		Line 127:

	===<tt>StartRun()</tt> and <tt>StopRun()</tt>===		===<tt>StartRun()</tt> and <tt>StopRun()</tt>===
	These reset ~~the decimation counter, and indirectly call <tt>VisualizationObject::reset()</tt>.~~		These reset all visualization objects.
	~~The <tt>waitForVisualizations()</tt> function in <tt>StartRun()</tt> waits for~~ all ~~<tt>WorkerThread</tt> tasks to complete before actually re-starting~~ visualization ~~activity~~.

	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	void ~~ComplexVisualizationDemoFilter~~::StartRun()		void
			VisualizationContainerDemoFilter::StartRun()
	{		{
	~~p->mDecimationCounter = 0;~~		p->resetVisualizations();
	~~p->waitForVisualizations();~~
	p->resetVisualizations();
	}		}

	void ~~ComplexVisualizationDemoFilter~~::StopRun()		void
			VisualizationContainerDemoFilter::StopRun()
	{		{
	~~p->waitForVisualizations();~~		p->resetVisualizations();
	p->resetVisualizations();
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Mellinger: /* Process() function */

2023-06-14T16:24:58Z

Process() function

← Older revision		Revision as of 16:24, 14 June 2023
Line 114:		Line 114:

	===<tt>Process()</tt> function===		===<tt>Process()</tt> function===
	The <tt>Process()</tt> function ~~handles the test of the decimation counter, and~~ calls <tt>updateVisualizations()</tt> ~~if necessary. <tt>updateVisualizations()</tt>~~, in turn, ~~calls~~ <tt>VisualizationObject::update()</tt> for each visualization object contained in <tt>mVisualizations</tt>.		The <tt>Process()</tt> function calls <tt>updateVisualizations()</tt>, which, in turn, will call <tt>VisualizationObject::update()</tt> for each visualization object contained in <tt>mVisualizations</tt>.

	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	void ~~ComplexVisualizationDemoFilter~~::Process(		void VisualizationContainerDemoFilter::Process(
	const GenericSignal& Input,		const GenericSignal& Input,
	GenericSignal& Output)		GenericSignal& Output)
	{		{
	Output = Input;		Output = Input;
	~~if(p->mDecimationCounter == 0)~~
	p->updateVisualizations(Input);		p->updateVisualizations(Input);
	~~++p->mDecimationCounter %= p->mDecimation;~~
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Mellinger: /* VisualizationObject::asyncUpdate() */

2023-06-14T16:22:38Z

VisualizationObject::asyncUpdate()

@@ Line 110: / Line 110: @@
      mVis.Send(CfgID::WindowFrame, true);
      mVis.Send(GenericSignal());
+}
 </syntaxhighlight>

Mellinger: /* VisualizationObject::reset() */

2023-06-14T16:22:06Z

VisualizationObject::reset()

← Older revision		Revision as of 16:22, 14 June 2023
Line 86:		Line 86:

	===<tt>VisualizationObject::reset()</tt>===		===<tt>VisualizationObject::reset()</tt>===
	This function resets the visualization window's position and size before sending an empty ~~reference frame~~ to the ~~operator~~.		This function resets the visualization window's position and size before sending an empty signal to the Operator
			(this will enforce creation of the visualization display on the Operator side).
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	void		void
	~~ComplexVisualizationDemoFilter~~::Private::VisualizationObject::reset()		VisualizationContainerDemoFilter::Private::VisualizationObject::reset()
	{		{
	// ~~place window into a container window named "CPLX" (will be created implicitly)~~		// reset position and size
	mVis.Send(CfgID::PlacementVis, "~~CPLX~~");		mVis.Send(CfgID::PlacementVis, "CNTR");
	mVis.Send(CfgID::PlacementRow, mRow);		mVis.Send(CfgID::PlacementRow, mRow + 1); // rows are one-based
	mVis.Send(CfgID::PlacementCol, mCol);		mVis.Send(CfgID::PlacementCol, mCol + 1); // columns are one-based
	mVis.Send(CfgID::~~WindowFrame~~, ~~false~~); ~~// hide title~~		mVis.Send(CfgID::Visible, true);
	mVis.Send(CfgID::~~Visible~~, true);		mVis.Send(CfgID::FixedScale, true);
			mVis.Send(CfgID::MinValue, mValueUnit.RawMin());
	~~// paint an empty image~~		mVis.Send(CfgID::MaxValue, mValueUnit.RawMax() * 1.1);
	~~mpInfoField->SetText~~(~~mInfo~~);		mVis.Send(CfgID::ShowStatusBar, false);
	~~mpInfoField->SetVisible~~(~~true~~);		mVis.Send(CfgID::SampleUnit, mSampleUnit.RawToPhysical(1));
	~~mpValueField->SetVisible~~(~~false~~);		mVis.Send(CfgID::ShowYTicks, false);
	~~mpShape->SetVisible~~(false);		LabelList markers;
	~~mImage~~.~~SetColor~~(p-~~>mBackground~~);		markers.push_back(Label(mValueUnit.PhysicalToRaw("1"), "1\|red\|-\|0.5"));
	~~mImage~~.~~Paint~~();		markers.push_back(Label(mValueUnit.PhysicalToRaw("0.5"), "0.5\|green\|-.\|0.5"));
	mVis.~~SendReferenceFrame(mImage.BitmapData~~());		mVis.Send(CfgID::YAxisMarkers, markers);
	~~mpShape->SetVisible~~(~~true~~);		mVis.Send(CfgID::WindowTitle, mTitle);
	~~mpValueField->SetVisible~~(true);		mVis.Send(CfgID::WindowFrame, true);
	~~mpInfoField->SetVisible~~(~~false~~);		mVis.Send(GenericSignal());
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Mellinger: /* VisualizationObject::update() */

2023-06-14T16:19:08Z

VisualizationObject::update()

← Older revision		Revision as of 16:19, 14 June 2023
Line 74:		Line 74:

	===<tt>VisualizationObject::update()</tt>===		===<tt>VisualizationObject::update()</tt>===
	This function ~~runs <tt>VisualizationObject::asyncUpdate()</tt> inside~~ the ~~object's worker thread in order~~ to ~~avoid interference with timing of~~ the ~~main BCI2000 thread (pipeline thread)~~.		This function computes the correlation matrix element, and sends it to the visualization display wrapped into a ''GenericSignal'' object.
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	void		void
	~~ComplexVisualizationDemoFilter~~::Private::VisualizationObject::update(const GenericSignal& Input)		VisualizationContainerDemoFilter::Private::VisualizationObject::update(const GenericSignal& Input)
	{		{
	mComputation.run(Input);		mComputation.run(Input);
	~~mWorker~~.~~Run~~(~~mCallAsyncUpdate~~); ~~// will fail silently if worker still busy~~		mSignal(0, 0) = mComputation.result;
			mVis.Send(mSignal);
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Mellinger: /* Declaration of internal variables */

2023-06-14T16:15:56Z

Declaration of internal variables

← Older revision		Revision as of 16:15, 14 June 2023
Line 26:		Line 26:
	struct VisualizationContainerDemoFilter::Private		struct VisualizationContainerDemoFilter::Private
	{		{
			GenericVisualization mContainerVis;

			class VisualizationObject;
			std::vector<VisualizationObject *> mVisualizations;

	~~class VisualizationObject;~~		~Private()
	~~std::vector<VisualizationObject*> mVisualizations;~~		{
			destroyVisualizations();
	~Private() { destroyVisualizations(); }		}
	// Creates visualization objects for pairs of channels.		// Creates visualization objects for pairs of channels.
	void createVisualizations(const SignalProperties&~~, int maxWindows~~);		void createVisualizations(const SignalProperties &);
	// Destroys all visualization objects.		// Destroys all visualization objects.
	void destroyVisualizations();		void destroyVisualizations();
	// ~~Resets~~ visualizations to their initial state.		// Sets visualizations to their initial state.
	void resetVisualizations();		void resetVisualizations();
	// Computes data values, and ~~asynchronously~~ updates visualization ~~bitmaps~~.		// Computes data values, and updates visualization windows.
	void updateVisualizations(const GenericSignal&);		void updateVisualizations(const GenericSignal &);
	~~// Waits for asynchronous activity in all visualizations to terminate.~~
	~~void waitForVisualizations();~~

	~~class VisualizationObject~~
	{
	~~public:~~
	~~VisualizationObject(const Private*, const std::string& visID);~~
	~~~VisualizationObject();~~
	~~void setTitle(const std::string&, const std::string& info = "");~~
	~~void setPosition(int row, int col, int rowSpan = 1, int colSpan = 1);~~
	~~void reset();~~
	~~void update(const GenericSignal&);~~
	~~void wait(~~);

	~~struct Computation~~		class VisualizationObject
	{		{
	~~int inputCh1, inputCh2~~;		public:
	~~double result~~;		VisualizationObject(const std::string &visID);
	~~// run~~() ~~is called whenever a new signal arrives.~~		~VisualizationObject();
	void ~~run~~(const ~~GenericSignal~~&);		void setTitle(const std::string &);
	~~} mComputation~~;		void configureSignal(const SignalProperties&);
			void setPosition(int row, int col);
	~~private:~~		void reset();
	void ~~asyncUpdate~~();		void update(const GenericSignal &);

	~~MemberCall<~~void(VisualizationObject*)~~> mCallAsyncUpdate~~;		struct Computation
			{
			int inputCh1, inputCh2;
			double result;
			// run() is called whenever a new signal arrives.
			void run(const GenericSignal &);
			} mComputation;

	~~const Private* p~~;		private:
	~~WorkerThread mWorker~~;		GenericVisualization mVis;
	~~BitmapVisualization mVis~~;		GenericSignal mSignal;
	std::string mTitle~~, mInfo~~;		PhysicalUnit mSampleUnit, mValueUnit;
	~~GUI::Rect mPosition;~~		std::string mTitle;
	~~GUI::GraphDisplay mImage;~~		int mRow, mCol;
	~~PieShape* mpShape~~;		};
	~~TextField* mpValueField, *mpInfoField;~~
	};
	};		};
	</syntaxhighlight>		</syntaxhighlight>

← Older revision		Revision as of 16:28, 14 June 2023
Line 144:		Line 144:

	==See also==		==See also==
	[[Programming Reference:GraphDisplay Class]], [[Programming Reference:GenericVisualization Class]], [[Programming Reference:VisualizationDemo Signal Processing]], [[Technical Reference:Visualization Properties]]		[[Programming Reference:GraphDisplay Class]], [[Programming Reference:GenericVisualization Class]], [[Programming Reference:VisualizationDemo Signal Processing]], [[Programming Reference:ComplexVisualizationDemo Signal Processing]], [[Technical Reference:Visualization Properties]]

	[[Category:Framework API]][[Category:Howto]][[Category:Development]]		[[Category:Framework API]][[Category:Howto]][[Category:Development]]