ClassificationDataStream.h

Go to the documentation of this file.

#ifndef GRT_CLASSIFICATION_DATA_STREAM_HEADER
#define GRT_CLASSIFICATION_DATA_STREAM_HEADER

#include "../Util/GRTCommon.h"
#include "TimeSeriesPositionTracker.h"
#include "ClassificationData.h"
#include "TimeSeriesClassificationData.h"

GRT_BEGIN_NAMESPACE

class GRT_API ClassificationDataStream{
public:
 
 ClassificationDataStream(const UINT numDimensions=0,const std::string datasetName = "NOT_SET",const std::string infoText = "");
    
 ClassificationDataStream(const ClassificationDataStream &rhs);
    
 virtual ~ClassificationDataStream();

 ClassificationDataStream& operator= (const ClassificationDataStream &rhs);

 inline ClassificationSample& operator[] (const UINT i){
  return data[i];
 }

    inline const ClassificationSample& operator[] (const UINT i) const {
        return data[i];
    }

 void clear();
    
    bool setNumDimensions(const UINT numDimensions);
    
    bool setDatasetName(const std::string datasetName);
    
    bool setInfoText(const std::string infoText);
    
    bool setClassNameForCorrespondingClassLabel(const std::string className,const UINT classLabel);
    
 bool addSample(const UINT classLabel,const VectorFloat &sample);

    bool addSample(const UINT classLabel,const MatrixFloat &sample);
    
 bool removeLastSample();
    
 UINT eraseAllSamplesWithClassLabel(const UINT classLabel);
    
 bool relabelAllSamplesWithClassLabel(const UINT oldClassLabel,const UINT newClassLabel);
    
    bool setExternalRanges(const Vector< MinMax > &externalRanges,const bool useExternalRanges = false);
    
    bool enableExternalRangeScaling(const bool useExternalRanges);
    
    bool scale(const Float minTarget,const Float maxTarget);
    
 bool scale(const Vector<MinMax> &ranges,const Float minTarget,const Float maxTarget);
    
    bool resetPlaybackIndex(const UINT playbackIndex);
    
    ClassificationSample getNextSample();
    
 TimeSeriesClassificationData getAllTrainingExamplesWithClassLabel(const UINT classLabel) const;
    
    bool save(const std::string &filename);
    
    bool load(const std::string &filename);

 bool saveDatasetToFile(const std::string &filename);
    
    bool saveDatasetToCSVFile(const std::string &filename);
    
 bool loadDatasetFromFile(const std::string &filename);
    
 bool loadDatasetFromCSVFile(const std::string &filename,const UINT classLabelColumnIndex=0);
    
    bool printStats() const;
    
    std::string getDatasetName() const { return datasetName; }
    
    std::string getInfoText() const { return infoText; }
    
 UINT inline getNumDimensions() const { return numDimensions; }
 
 UINT inline getNumSamples() const { return totalNumSamples; }
 
 UINT inline getNumClasses() const { return (UINT)classTracker.size(); }
    
    UINT getMinimumClassLabel() const;
    
    UINT getMaximumClassLabel() const;
    
    UINT getClassLabelIndexValue(const UINT classLabel) const;
    
    std::string getClassNameForCorrespondingClassLabel(const UINT classLabel);
    
 Vector<MinMax> getRanges() const;
    
    Vector< ClassTracker > getClassTracker() const { return classTracker; }
    
    Vector< TimeSeriesPositionTracker > getTimeSeriesPositionTracker() const { return timeSeriesPositionTracker; }
    
 std::deque< ClassificationSample > getClassificationSamples() const { return data; }
    
    ClassificationDataStream getSubset(const UINT startIndex,const UINT endIndex) const;
    
    TimeSeriesClassificationData getTimeSeriesClassificationData( const bool includeNullGestures = false ) const;
    
    ClassificationData getClassificationData( const bool includeNullGestures = false ) const;
    
    MatrixFloat getTimeSeriesData( const TimeSeriesPositionTracker &trackerInfo ) const;
    
    MatrixFloat getDataAsMatrixFloat() const;
    
    Vector< UINT > getClassLabels() const;

protected:
    std::string datasetName;                                     
    std::string infoText;                                        
 UINT numDimensions;          
 UINT totalNumSamples;
 UINT lastClassID;
    UINT playbackIndex;
 bool trackingClass;
    bool useExternalRanges;                                 
    Vector< MinMax > externalRanges;                        
 Vector< ClassTracker > classTracker;
 std::deque< ClassificationSample > data;
 Vector< TimeSeriesPositionTracker > timeSeriesPositionTracker;
    
    DebugLog debugLog;                                      
    ErrorLog errorLog;                                      
    WarningLog warningLog;                                  
};

GRT_END_NAMESPACE

#endif //GRT_TIME_SERIES_CLASSIFICATION_DATA_STREAM_HEADER