Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
CAbstractTree
CAbstractTreeNode
CAbstractTreeNodeOrderingFunction
CAbstractTreeParentNode
CAbstractTreeValueNode
CAbstractTreeVariableNode
CAbstractVrpnPeripheralA VRPN peripheral abstraction, client side
CAlgorithmPairwiseDecisionThe CAlgorithmPairwiseDecision class This is the default class for every decision usable with the One Vs One pairwise strategy
CAlgorithmPairwiseDecisionHTDecision strategy for the One Vs One pairwise decision that implement the method describe in the article Hastie, Trevor; Tibshirani, Robert. Classification by pairwise coupling. The Annals of Statistics 26 (1998), no. 2, 451--471
CAlgorithmPairwiseDecisionVotingThe CAlgorithmPairwiseDecisionVoting class This strategy relies on a basic voting system. If class A beats class B, class A win 1 point and B 0 point. At the end, the vector of probability is composed by the normalized score of each class
CAlgorithmPairwiseStrategyPKPDThe CAlgorithmPairwiseStrategyPKPD class This strategy relies on the algorithm describe in the article . Price, S. Knerr, L. Personnaz, and G. Dreyfus. Pairwise neural network classifiers with probabilistic outputs. In G. Tesauro, D. Touretzky, and T. Leen (eds.) Advances in Neural Information Processing Systems 7 (NIPS-94), pp. 1109-1116. MIT Press, 1995
CBandFrequencyAverage
CBandFrequencyAverageDesc
CBCI2000ReaderHelperBCI2000 file format parser and utilities. Uses the m_oBitfield utility class
CBinaryBoolean1FunctionSymbols
CBinaryBoolean2FunctionSymbols
CBinaryBoolean3FunctionSymbols
CBinaryFunctionSymbols
CBottomTimeRuler
CBoxAlgorithmBCI2000ReaderThe class CBoxAlgorithmBCI2000Reader describes the box BCI2000 Reader
CBoxAlgorithmBCI2000ReaderDescDescriptor of the box BCI2000 Reader
CBoxAlgorithmConnectivityMeasureThe class CBoxAlgorithmConnectivityMeasure describes the box Connectivity Measure
CBoxAlgorithmConnectivityMeasureDescDescriptor of the box Connectivity Measure
CBoxAlgorithmDifferentialIntegralThe class CBoxAlgorithmDifferentialIntegral describes the box DifferentialIntegral
CBoxAlgorithmDifferentialIntegralDescDescriptor of the box DifferentialIntegral
CBoxAlgorithmErpPlotThe class CBoxAlgorithmErpPlot describes the box ERP plot
CBoxAlgorithmErpPlotDescDescriptor of the box ERP plot
CBoxAlgorithmHilbertThe class CBoxAlgorithmHilbert describes the box Phase and Envelope
CBoxAlgorithmHilbertDescDescriptor of the box Phase and Envelope
CBoxAlgorithmMessageReceiverThe class CBoxAlgorithmMessageReceiver describes the box Message Receiver
CBoxAlgorithmMessageReceiverDescDescriptor of the box Message Receiver
CBoxAlgorithmMessageSenderThe class CBoxAlgorithmMessageSender describes the box Message Sender
CBoxAlgorithmMessageSenderDescDescriptor of the box Message Sender
CBoxAlgorithmMessageSpyThe class CBoxAlgorithmMessageSpy describes the box Message Spy
CBoxAlgorithmMessageSpyDescDescriptor of the box Message Spy
CBoxAlgorithmModifiableSettingsThe class CBoxAlgorithmModifiableSettings describes the box ModifiableSettings
CBoxAlgorithmModifiableSettingsDescDescriptor of the box ModifiableSettings
CBoxAlgorithmMouseTrackingThe class CBoxAlgorithmMouseTracking describes the box Mouse tracking
CBoxAlgorithmMouseTrackingDescDescriptor of the box Mouse tracking
CBoxAlgorithmSharedMemoryWriterThe class CBoxAlgorithmSharedMemoryWriter describes the box SharedMemoryWriter
CBoxAlgorithmSharedMemoryWriterDescDescriptor of the box SharedMemoryWriter
CBoxAlgorithmSignalConcatenationThe class CBoxAlgorithmSignalConcatenation describes the box Signal Concatenation
CBoxAlgorithmSignalConcatenationDescDescriptor of the box Signal Concatenation
CBoxAlgorithmStreamedMatrixSwitchThe class CBoxAlgorithmStreamedMatrixSwitch describes the box Streamed Matrix Switch
CBoxAlgorithmStreamedMatrixSwitchDescDescriptor of the box Streamed Matrix Switch
CBoxAlgorithmTimeoutThe class CBoxAlgorithmTimeout describes the box Timeout
CBoxAlgorithmTimeoutDescDescriptor of the box Timeout
CBufferDatabase
CChannelSelector
CChannelSelectorDesc
CComparison1FunctionSymbols
CComparison2FunctionSymbols
CConfigurationDriverGenericOscilatorThe CConfigurationDriverGenericOscilator handles the configuration dialog specific to the Generic Oscilator driver
CConfigurationEnobio3GThe CConfigurationEnobio3G handles the configuration dialog specific to the Enobio3G device
CDisplayCueImageDesc
CEpoching
CEpochingDesc
CEquationGrammar
CFeatureAggregator
CFeatureAggregatorDesc
CFirstDifferenceDetrending
CFirstDifferenceDetrendingDesc
GDF::CFixedGDF1Header
GDF::CFixedGDF251Header
GDF::CFixedGDF2Header
CGDFFileReader
CGDFFileReaderDesc
CGDFFileWriter
CGDFFileWriterDesc
CGrazVisualizationDesc
CHandballBCIOgre application for the Handball application
CIdentifierGlobally used identifiaction classThis class is the basic class to use in order to identify objects in the OpenViBE platform. It can be used for class identification, for object identification and any user needed identification process
CIdentifierBase class to work with EBML identifiers
CIdentifierBase class to work with Automaton identifiers
CKeyboardStimulatorDesc
CMathConstantSymbols
CMatrixBasic standalone OpenViBE matrix implementationThis class offers a basic standalone impementation of the OpenViBE::IMatrix interface. This class can be directly instanciated and used
CMemoryBufferBasic standalone OpenViBE memory buffer implementationThis class offers a basic standalone impementation of the OpenViBE::IMemoryBuffer interface. This class can be directly instanciated and used
CNameValuePairListThis class handles a list of name/value pairs. It handles a (hidden) map associating string keys to string values.This class avoids the need to include stl's map header file in the C++ interface, thus preventing potential compile/link errors when dynamically loading modules
CoAdaptP300CEvidenceAccumulator
CoAdaptP300IEvidenceAccumulator
CoAdaptP300PropertyReader
CoAdaptP300SharedMemoryReader
COgreObjectAn OgreObject manages a 3D object in an Ogre scene
COgreResourceGroupOgre Resource Group management This class handles a resource group, possibly shared by multiple scenarios. Its reference count keeps track of when it is actually needed. Resources are freed when the count reaches 0
COgreSceneManagement of an Ogre scene This class creates a scene manager and a default 3D scene which can be populated using a simplified 3D API
COgreVisualisationHigh level Ogre initialisation & management This class initializes the Ogre library, creates 3D scenes, windows (views of 3D scenes) and objects that populate such scenes
COgreVRApplicationBasic framework to design VR applications
COgreWindowAn OgreWindow visualises a 3D scene This class manages a RenderWindow which contents are visualised in a single viewport
CPowerSpectrumChannelDisplay
CPowerSpectrumDatabase
CPowerSpectrumDisplayView
CSecondDifferenceDetrending
CSecondDifferenceDetrendingDesc
CSignalAverage
CSignalAverageDesc
CSignalDisplay
CSignalDisplayDesc
CSignalDisplayDrawable
CSignalDisplayLeftRuler
CSignalDisplayView
CSimple3DDatabase
CSimple3DView
CSpectrumDatabase
CStimulationSetBasic standalone OpenViBE stimulation set implementationThis class offers a basic standalone impementation of the OpenViBE::IStimulationSet interface. This class can be directly instanciated and used
CStreamedMatrixDatabase
CStringString class to avoid std::string in the interfaceThis class helps avoiding std::string being present in exposed C++ interface, eventually resulting in compile/link errors when dynamically loading modules
CTieFighterBCIOgre application for the application "Use-The-Force"
CTimeFrequencyMapChannelDisplay
CTimeFrequencyMapDisplayView
CTimeRuler
CTopographicMap2DView
CTopographicMap3DView
CTopographicMapDatabase
CUnaryBooleanFunctionSymbols
CUnaryFunctionSymbols
GDF::CVariableGDF1Header
GDF::CVariableGDFHeader
CVariableSymbols
CVisualisationContextVisualisation context made available to plugins and allowing them to interact with a 3D scene This class offers a simplified, library independent 3D API to be used by plugin developers
CVoxelView
CXMLStimulationScenarioPlayerDesc
ExternalP300EvidenceAccumulator
functionContext
GDF
GenericVRPNServerA class providing a very simple generic VRPN server capable of creating Analog and Button controls
GObservable
GObserver
GtkOVCustomCustom Gtk widget whose behaviour may be adapted to the developer's needs This widget is to be instanciated using the gtk_ov_custom_new function only
IAlgorithmAbstract algorithm, base element of OpenViBE processing objectsThis class should be derived by any plugin that is related to data processing. It basically has a parameterable interface contained in the IAlgorithmContext object. This interface stores several typed parameters which can be modified either by outside world in order to provide input paramters to this algorithm or by this algorithm itself in order to produce output parameters
IAlgorithmContextExectution context for algorithm objects
IAlgorithmDescAlgorithm plugin descriptorThis class should be derived by any plugin developer in order to describe a specific OpenViBE algorithm
IAlgorithmManagerManager for all kind of plugin algorithms
IAlgorithmProtoPrototype interface for algorithm
IAlgorithmProxyApplication interface to an algorithm plugin
IAttributable
IBoxComplete OpenViBE box interfaceThis interface can be used in order to fully describe an OpenViBE black box. It describes its identification values, its inputs, its outputs and its settings
IBoxAlgorithmAlgorithm to create/process/transform OpenViBE dataThis class should be derived by any plugin that is related to data processing. It can be data acquisition/production from an hardware device or from a file. It can be data processing/transforming, moving time information into frequency space for example. It can be data classification generating discrete classification events better than continuous data flow
IBoxAlgorithmContextSpecific context to use for box algorithm pluginsThis 'context' is given by the player to an algorithm plugin so it has all the necessary tools to work. This algorithm context mainly consists in getting other contexts which could be defined and used more generically (such as the box interface or a global player interface for example)
IBoxAlgorithmDescBox algorithm plugin descriptorThis class should be derived by any plugin developer in order to describe a specific OpenViBE box algorithm
IBoxIOMain OpenViBE box interface to communicate with the kernelThis context allows the object which uses it to check inputs states, read them, write outputs while being in a dynamic context (used by player)
IBoxListenerContextExectution context for box algorithm descriptors
IBoxProtoOpenViBE box prototypeThis class is used by a plugin algorithm descriptor to let the OpenViBE platform know what an algorithm box looks like. It declares several things, like it input types, output types and settings
ICommentA comment class for scenariosThis interface can be used in order to fully describe an OpenViBE comment in order to help the understanding of a given scenario
IConfigurableConfigurable object interface
IConfigurationManagerManager for all kind of configuration
IDriverBase class for all the OpenViBE acquisition server drivers
IDriverCallbackBase class for all the OpenViBE acquisition server driver callbacks
IDriverContextBase class for kernel functioanlities access from the driver classes
IHeaderBase class for an OpenViBE header container
IKernelContextKernel context interface, gives access to each manager the kernel owns
IKernelDescA kernel description
IKernelLoaderThis class allows an OpenViBE application to load a kernel module
IKernelObjectBase class for all kernel objects
IKernelObjectFactoryKernel object factory, creates all kernel objects
ILinkLink information between OpenViBE boxThis class collects informations between OpenViBE boxes : box identifiers and input / output indices
ILogListenerLog manager's listener interface
ILogManagerLog manager
IMaterialPassActionA class which calls the action for each pass of each technique
IMatrixBasic OpenViBE matrix interface
IMemoryBufferBasic OpenViBE memory buffer interface
IMessageBase message class
IMessageClockClock message
IMessageEventEvent message
IMessageSignalSignal message
IMessageWithDataA type of message that can contain different kinds of arbitrary dataA message that can contain different kinds of data. The intended usage is for the message to be exchanged between boxes. A message can hold four types of data: uint64, float64, CString and IMatrix. Each data item is accessed by its string identifier key using a getter/setter corresponding to the data type. The key is unique within the data type
IObjectBase class for all the OpenViBE platform objects
IObjectVisitorContextExectution context for visitor objects
IParameterGeneric parameter handler for configurable objects
IPlayerThe main player classA player is responsible for the playback of a specific scenario. This player scenario is provided at initialisation stage and should not be changed until the player terminates. The player idea of calling a "play" function forces the use of threads in order to avoid CPU locking. Thus we prefer the idea of having a "short-time" function that is to be called repeatedly until the player terminates. This is the role of the IPlayer::loop function, that should be called repeatedly by the outside application
IPlayerContextPlayer interface for plugin objectsInstances of this class are given to plugin object so they can communicate with the platform kernel, providing services such as message sending etc..
IPlayerManagerThe manager responsible for scenario playbackThe player manager is responsible for creating the different player instances. Each player is responsible for the playback of a specific scenario
IPluginManagerLog manager
IPluginModulePlugin module
IPluginModuleContextPlugin context
IPluginObjectBase class for plugin objectThis class is the base class for all the concrete plugin classes that extend the OpenViBE platform. It comes with several basic functions each plugin should have in order to work in the OpenViBE platform
IPluginObjectDescBase class for plugin descriptorThis class is the base class for all the plugin description classes. It contains basic functions that could be used for each plugin description. Derived plugin descriptions will be used as a prototype of what they can create
IProcessingUnitProcessing unit information for OpenViBE boxes
IReaderEBML processing class
IReaderCallbackCallback class to use when parsing the EBML stream
IReaderHelperHelper to read basic EBML types
IScenarioA static OpenViBE scenarioThis class is a static scenario description. It is used to manipulate an OpenViBE box/connection collection..
IScenarioManagerThe scenario managerThis manager is responsible to organize and handle all the scenarios of the kernel
IServerExtensionContextStatic context of a Server Extension object
IServerExtensionDescServer Extension plugin descriptor
IServerExtensionDynamicContextDynamic context of a Server Extension objectThis class contains accessors to data structures made available by the driver running in the Acquisition Server during the acquisition
IServerExtensionProtoPrototype interface for a server extension
ISharedMemoryReader
IsProgrammableAction to know if is programmable. Main pass is programmable ? ie includes either a vertex or fragment program
IStimulationSetBasic OpenViBE stimulation set interface
IStreamDisplayDrawableAbstract class of objects than can be updated by an IStreamDatabase object
ITreeViewCBTree view interface It must be implemented by classes which communicate with the IVisualisationTree class in order to display the contents of the visualisation tree
ITypeManagerType manager, provides information on platform's handled types, parameters, streams etc..
IVisualisationContextVisualisation manager interface for plugin objects
IVisualisationManagerThe VisualisationManager handles IVisualisationTree objects It maintains a list of IVisualisationTree objects, each of which is associated to a scenario. This manager is used both at scenario creation time (to load or create IVisualisationTree objects), and when the scenario is being run (to forward IVisualisationWidget pointers to the related IVisualisationTree)
IVisualisationTreeHandles visualisation widgets and their arrangement in space This interface lets applications configure visualisation widgets by adding them to windows and tabs, positioning them next to each other using paned widgets, and resizing them as the user sees fit. All widgets are saved in a symbolic way as IVisualisationWidget instances referenced in a tree store. Methods of this class are essentially meant to be called from an external class inheriting from the ITreeViewCB interface, for offline design or online use of the widgets
IVisualisationManager::IVisualisationTreeEnumAn interface used to iteratively notify its creator of the existence of IVisualisationTree objects
IVisualisationWidgetInterface of visualisation widgets that are handled by an IVisualisationTree These objects are stored in an IVisualisationTree object as they are being created and modified to suit the graphical needs of a scenario
IWriterEBML formating class
IWriterCallbackCallback class to use when creating the EBML stream
IWriterHelperHelper to write basic EBML types
IXMLHandlerThis class is design to help about XML manipulation
IXMLNodeSymbolize a node in a XML tree structure
MaterialSetAwarenessAction to set the awareness color. Carefull MaterialSetAwareness is exclusive, you have to choose beetween, MaterialSetMaterialName and MaterialSetAwareness
MaterialSetDiffuseAction to set the diffuse color. Sets the color
MaterialSetMaterialName
MaterialSetSceneBlendingAction to set the scene blending. Sets the blending method to use to adjust transparency
MaterialSetShaderAction to set shader. Allow user to add fragment and shader on a new Pass
MaterialSetTransparencyAction to change this instance transparency
MaterialVertexBufferAction to modify a Vertex Buffer
P300InterfacePropertyReader
P300ScreenLayoutReader
PropertyBase class for properties. A property is essentially a <name,value> pair
ISharedMemoryReader::SharedVariableHandler
SMatrix
TParameterHandler< T >Helper class in order to manipulate IParameter and IParameter values natively
WordPredictionEngine
WordPredictionInterface