File List

Here is a list of all documented files with brief descriptions:

AdaBoost.cpp
AdaBoost.h
AdaBoostClassModel.h	This file implements a container for an AdaBoost class model
ANBC.cpp
ANBC.h
ANBC_Model.cpp
ANBC_Model.h	This class implements a container for an ANBC model
BAG.cpp
BAG.h
BernoulliRBM.cpp
BernoulliRBM.h	This class implements a Bernoulli Restricted Boltzmann machine
Cholesky.cpp
Cholesky.h	This code is based on the LU Decomposition code from Numerical Recipes (3rd Edition)
CircularBuffer.h
ClassificationData.cpp
ClassificationData.h
ClassificationDataStream.cpp
ClassificationDataStream.h	The ClassificationDataStream is the main data structure for recording, labeling, managing, saving, and loading datasets that can be used to test the continuous classification abilities of the GRT supervised learning algorithms
ClassificationResult.h	The ClassificationResult class provides a data structure for storing the results of a classification test
ClassificationSample.cpp
ClassificationSample.h
Classifier.cpp
Classifier.h
ClassLabelChangeFilter.cpp
ClassLabelChangeFilter.h	The Class Label Change Filter signals when the predicted output of a classifier changes. For instance, if the output stream of a classifier was {1,1,1,1,2,2,2,2,3,3}, then the output of the filter would be {1,0,0,0,2,0,0,0,3,0}. This module is useful if you want to debounce a gesture and only care about when the gesture label changes
ClassLabelFilter.cpp
ClassLabelFilter.h	The Class Label Filter is a useful post-processing module which can remove erroneous or sporadic prediction spikes that may be made by a classifier on a continuous input stream of data
ClassLabelTimeoutFilter.cpp
ClassLabelTimeoutFilter.h	The Class Label Timeout Filter is a useful post-processing module which debounces a gesture (i.e. it stops a single gesture from being recognized multiple times over a short time frame). For instance, it is normally the case that whenever a user performs a gesture, such as a swipe gesture for example, that the recognition system may recognize this single gesture several times because the user's movements are being sensed at a high sample rate (i.e. 100Hz). The Class Label Timeout Filter can be used to ensure that a gesture, such as the previous swipe gesture example, is only recognize once within any given timespan
ClassTracker.h
Clusterer.cpp
Clusterer.h	This is the main base class that all GRT Clustering algorithms should inherit from
ClusterTree.cpp
ClusterTree.h	This class implements a Cluster Tree. This can be used to automatically build a cluster model (where each leaf node in the tree is given a unique cluster label) and then predict the best cluster label for a new input sample
ClusterTreeNode.h	This file implements a ClusterTreeNode, which is a specific type of node used for a ClusterTree
CommandLineParser.h
Context.cpp
Context.h	This is the main base class that all GRT Feature Extraction algorithms should inherit from
ContinuousHiddenMarkovModel.cpp
ContinuousHiddenMarkovModel.h	This class implements a continuous Hidden Markov Model
DataType.h
DeadZone.cpp
DeadZone.h
DebugLog.cpp
DebugLog.h
DecisionStump.cpp
DecisionStump.h	This class implements a DecisionStump, which is a single node of a DecisionTree
DecisionTree.cpp
DecisionTree.h
DecisionTreeClusterNode.cpp
DecisionTreeClusterNode.h
DecisionTreeNode.cpp
DecisionTreeNode.h
DecisionTreeThresholdNode.cpp
DecisionTreeThresholdNode.h
DecisionTreeTripleFeatureNode.cpp
DecisionTreeTripleFeatureNode.h
Derivative.cpp
Derivative.h
Dict.h
DiscreteHiddenMarkovModel.cpp
DiscreteHiddenMarkovModel.h	This class implements a discrete Hidden Markov Model
DoubleMovingAverageFilter.cpp
DoubleMovingAverageFilter.h
DTW.cpp
DTW.h
DynamicType.h
EigenvalueDecomposition.cpp
EigenvalueDecomposition.h
EnvelopeExtractor.cpp
EnvelopeExtractor.h
ErrorLog.cpp
ErrorLog.h
EvolutionaryAlgorithm.h
FastFourierTransform.cpp
FastFourierTransform.h
FeatureExtraction.cpp
FeatureExtraction.h	This is the main base class that all GRT Feature Extraction algorithms should inherit from
FFT.cpp
FFT.h
FFTFeatures.cpp
FFTFeatures.h	This class implements the FFTFeatures featue extraction module
FileParser.h
FiniteStateMachine.cpp
FiniteStateMachine.h
FIRFilter.cpp
FIRFilter.h
FSMParticle.h
FSMParticleFilter.h
Gate.cpp
Gate.h
GaussianMixtureModels.cpp
GaussianMixtureModels.h	This class implements a Gaussian Miture Model clustering algorithm. The code is based on the GMM code from Numerical Recipes (3rd Edition)
GestureRecognitionPipeline.cpp
GestureRecognitionPipeline.h
GMM.cpp
GMM.h
GridSearch.h
GRT.h	This is the main GRT header. You should include this to access all the GRT classes in your project
GRTBase.cpp
GRTBase.h	This file contains the GRTBase class. This is the core base class for all the GRT modules
GRTCommon.h
GRTException.h
GRTTypedefs.h
GRTVersionInfo.h
HierarchicalClustering.cpp
HierarchicalClustering.h	This class implements a basic Hierarchial Clustering algorithm
HighPassFilter.cpp
HighPassFilter.h
HMM.cpp
HMM.h
HMMEnums.h	This class acts as the main interface for using a Hidden Markov Model
IndexedDouble.h
Individual.h
InfoLog.cpp
InfoLog.h
KMeans.cpp
KMeans.h	This class implements the KMeans clustering algorithm
KMeansFeatures.cpp
KMeansFeatures.h
KMeansQuantizer.cpp
KMeansQuantizer.h	The KMeansQuantizer module quantizes the N-dimensional input vector to a 1-dimensional discrete value. This value will be between [0 K-1], where K is the number of clusters used to create the quantization model. Before you use the KMeansQuantizer, you need to train a quantization model. To do this, you select the number of clusters you want your quantizer to have and then give it any training data in the following formats:
KNN.cpp
KNN.h
LeakyIntegrator.cpp
LeakyIntegrator.h
libsvm.cpp
libsvm.h
LinearLeastSquares.h	This class implements a basic Linear Least Squares algorithm
LinearRegression.cpp
LinearRegression.h
Log.h
LogisticRegression.cpp
LogisticRegression.h
LowPassFilter.cpp
LowPassFilter.h
LUDecomposition.cpp
LUDecomposition.h
Matrix.h	The Matrix class is a basic class for storing any type of data. This class is a template and can therefore be used with any generic data type
MatrixFloat.cpp
MatrixFloat.h
MeanShift.h	This class implements the MeanShift clustering algorithm
MedianFilter.cpp
MedianFilter.h
Metrics.cpp
Metrics.h	This file contains the Metrics class, it can be used to compute common metrics such as accuracy, rms error, etc.
MinDist.cpp
MinDist.h
MinDistModel.cpp
MinDistModel.h	This class implements the MinDist classifier algorithm
MinMax.h
MixtureModel.h	This class implements a MixtureModel, which is a container for holding a class model for the GRT::GMM class
MLBase.cpp
MLBase.h
MLP.cpp
MLP.h
MovementDetector.cpp
MovementDetector.h	This class implements a simple movement detection algorithm. This can be used to detect periods of 'low movement' and 'high movement' to act as additional context for other GRT algorithms
MovementIndex.cpp
MovementIndex.h	This class implements the MovementIndex feature module. The MovementIndex module computes the amount of movement or variation within an N-dimensional signal over a given time window. The MovementIndex class is good for extracting features that describe how much change is occuring in an N-dimensional signal over time. An example application might be to use the MovementIndex in combination with one of the GRT classification algorithms to determine if an object is being moved or held still
MovementTrajectoryFeatures.cpp
MovementTrajectoryFeatures.h	This class implements the MovementTrajectory feature extraction module
MovingAverageFilter.cpp
MovingAverageFilter.h
MultidimensionalRegression.cpp
MultidimensionalRegression.h
Neuron.cpp
Neuron.h	This class implements a Neuron that is used by the Multilayer Perceptron
Node.cpp
Node.h	This class contains the main Node base class
Observer.h
ObserverManager.h
Particle.h
ParticleClassifier.cpp
ParticleClassifier.h
ParticleClassifierParticleFilter.h
ParticleFilter.h	This class implements a template based ParticleFilter. The user is required to implement the predict and update functions for their specific task
ParticleSwarmOptimization.h	This class implements a template based ParticleSwarmOptimization algorithm
PeakDetection.cpp
PeakDetection.h
PostProcessing.cpp
PostProcessing.h
PreProcessing.cpp
PreProcessing.h	This is the main base class that all GRT PreProcessing algorithms should inherit from
PrincipalComponentAnalysis.cpp
PrincipalComponentAnalysis.h
PSOParticle.h
RadialBasisFunction.cpp
RadialBasisFunction.h	This class implements a Radial Basis Function Weak Classifier. The Radial Basis Function (RBF) class fits an RBF to the weighted training data so as to maximize the number of positive training samples that are inside a specific region of the RBF (this region is set by the GRT::RadialBasisFunction::positiveClassificationThreshold parameter). After the RBF has been trained, it will output 1 if the input data is inside the RBF positive classification region, otherwise it will output 0
Random.cpp
Random.h
RandomForests.cpp
RandomForests.h
RangeTracker.cpp
RangeTracker.h	The RangeTracker can be used to keep track of the expected ranges that might occur in a dataset. These ranges can then be used to set the external ranges of a dataset for several of the GRT DataStructures
RBMQuantizer.cpp
RBMQuantizer.h	The SOMQuantizer module quantizes the N-dimensional input vector to a 1-dimensional discrete value. This value will be between [0 K-1], where K is the number of clusters used to create the quantization model. Before you use the SOMQuantizer, you need to train a quantization model. To do this, you select the number of clusters you want your quantizer to have and then give it any training data in the following formats:
Regressifier.cpp
Regressifier.h	This is the main base class that all GRT Regression algorithms should inherit from
RegressionData.cpp
RegressionData.h	The RegressionData is the main data structure for recording, labeling, managing, saving, and loading datasets that can be used to train and test the GRT supervised regression algorithms
RegressionSample.cpp
RegressionSample.h	This class stores the input vector and target vector for a single labelled regression instance
RegressionTree.cpp
RegressionTree.h
RegressionTreeNode.h	This file implements a RegressionTreeNode, which is a specific type of node used for a RegressionTree
RMSFilter.cpp
RMSFilter.h
SavitzkyGolayFilter.cpp
SavitzkyGolayFilter.h
SelfOrganizingMap.cpp
SelfOrganizingMap.h	This class implements the Self Oganizing Map clustering algorithm
Softmax.cpp
Softmax.h
SoftmaxModel.h	This file implements a container for a Softmax model
SOMQuantizer.cpp
SOMQuantizer.h	The SOMQuantizer module quantizes the N-dimensional input vector to a 1-dimensional discrete value. This value will be between [0 K-1], where K is the number of clusters used to create the quantization model. Before you use the SOMQuantizer, you need to train a quantization model. To do this, you select the number of clusters you want your quantizer to have and then give it any training data in the following formats:
SVD.cpp
SVD.h
SVM.cpp
SVM.h
SwipeDetector.cpp
SwipeDetector.h
TestingLog.cpp
TestingLog.h
TestInstanceResult.h	The TestInstanceResult class provides a data structure for storing the results of a classification or regression test instance
TestResult.h	The TestResult class provides a data structure for storing the results of a classification or regression test
ThreadPool.cpp
ThreadPool.h	The ThreadPool class implements a flexible inteface for performing a large number of batch tasks. You need to build the GRT with GRT_CXX11_ENABLED, otherwise the ThreadPool class will be empty (as it requires C++11 support)
ThresholdCrossingDetector.cpp
ThresholdCrossingDetector.h	This class implements a threshold crossing detector
TimeDomainFeatures.cpp
TimeDomainFeatures.h	This class implements the TimeDomainFeatures feature extraction module
Timer.h
TimeseriesBuffer.cpp
TimeseriesBuffer.h	This class implements the TimeseriesBuffer feature extraction module
TimeSeriesClassificationData.cpp
TimeSeriesClassificationData.h	The TimeSeriesClassificationData is the main data structure for recording, labeling, managing, saving, and loading training data for supervised temporal learning problems. Unlike the ClassificationData, in which each sample consists of 1 N dimensional datum, a TimeSeriesClassificationData sample will consist of an N dimensional time series of length M. The length of each time series sample (i.e. M) can be different for each datum in the dataset
TimeSeriesClassificationSample.cpp
TimeSeriesClassificationSample.h	This class stores the timeseries data for a single labelled timeseries classification sample
TimeSeriesClassificationSampleTrimmer.cpp
TimeSeriesClassificationSampleTrimmer.h	This class provides a useful tool to automatically trim timeseries data
TimeSeriesPositionTracker.h	This class can be used to track the class label, start and end indexs for labelled data
TimeStamp.h
TrainingDataRecordingTimer.cpp
TrainingDataRecordingTimer.h	The TrainingDataRecordingTimer is a tool to help record your training data
TrainingLog.cpp
TrainingLog.h
TrainingResult.h	The TrainingResult class provides a data structure for storing the results of a classification or regression training iteration
Tree.cpp
Tree.h	This class implements the base class Tree used for the DecisionTree, RegressionTree and ClusterTree
UnlabelledData.cpp
UnlabelledData.h	The UnlabelledData class is the main data container for supporting unsupervised learning
Util.cpp
Util.h	This file contains the Util class, a wrapper for a number of generic functions that are used throughout the GRT. This includes functions for scaling data, finding the minimum or maximum values in a double or UINT vector, etc. Many of these functions are static functions, which enables you to use them without having to create a new Util instance, for instance, you can directly call: Util::sleep( 1000 ); to use the sleep function
Vector.h	The Vector class is a basic class for storing any type of data. The default Vector is an interface for std::vector, but the idea is this can easily be changed when needed (e.g., when running the GRT on an embedded device with limited STL support). This class is a template and can therefore be used with any generic data type
VectorFloat.cpp
VectorFloat.h
WarningLog.cpp
WarningLog.h
WeakClassifier.cpp
WeakClassifier.h	This is the main base class for all GRT WeakClassifiers
WeightedAverageFilter.cpp
WeightedAverageFilter.h
ZeroCrossingCounter.cpp
ZeroCrossingCounter.h