modules/HMMModule.cpp

Go to the documentation of this file.

#include "HMMModule.h"
#include <string>
#include "../framedata/VectorFrameData.h"
#include "../framedata/IntegerFrameData.h"
#include "../framedata/SignalFrameData.h"
#include "../visualizer/HMMModuleGUI.h"
#include "../util/Error.h"
#include <iostream>

HMMModule::HMMModule(AbstractModule *successor) :
    ProcessModule(successor),
    m_hasGestureStarted(false),
    m_trainGestureID(0)
{
    setGUI(new HMMModuleGUI(this));
}

HMMModule::~HMMModule()
{
    for (Evaluators::iterator it = m_gestureClassificators.begin();
            it != m_gestureClassificators.end(); ++it) {
        delete it->first;
        delete it->second;
    }
}

void HMMModule::processFrameData(IFrameData *data)
{
    if (isSignal(data, SignalFrameData::SIG_START_GESTURE)) {
        m_hasGestureStarted = true;
        m_gesture.clear();
        delete data;
        return;
    }
    // no gesture yet -> break
    if (!m_hasGestureStarted) {
        delete data;
        return;
    }

    // gesture has ended - classify
    if (isSignal(data, SignalFrameData::SIG_STOP_GESTURE)) {
        delete data;
        if (m_trainGestureID == 0) {
            classifyRecordedGesture();
        } else {
            trainRecordedGesture();
        }
        return;
    }

    assertFramedataType(data, "Vector3D", "HMMModule::processFrameData");

    // record gesture
    m_gesture.push_back(static_cast<VectorFrameData*>(data)->getData());
    delete data;
}

int HMMModule::addGesture(int nClusters, int nStates)
{
    m_gestureClassificators.push_back(std::make_pair(
                new KMeanCluster(nClusters),
                new LeftToRightHMM(nStates, nClusters)
            ));
    return m_gestureClassificators.size()-1;
}

void HMMModule::delGesture(size_t gestureID)
{
    // TODO: have to find another way to do this.
    Evaluators::iterator it = m_gestureClassificators.begin();
    for (size_t i = 0; it != m_gestureClassificators.end(); ++it, ++i) {
        if (i == gestureID) {
            delete it->first;
            delete it->second;
            m_gestureClassificators.erase(it);
            return;
        }
    }
}

void HMMModule::clearGestures()
{
    Evaluators::iterator it;
    for (it = m_gestureClassificators.begin(); it != m_gestureClassificators.end(); ++it) {
        delete it->first;
        delete it->second;
    }
    m_gestureClassificators.clear();
}

void HMMModule::trainGesture(size_t gestureID)
{
    m_trainGestureID = gestureID;
}

void HMMModule::stopTraining() 
{
    m_trainGestureID = 0;
}

void HMMModule::classifyRecordedGesture() 
{
    double maxProp = 0.4, prop = -1;
    int maxPropGestureID = 0, gestureID = 1;
    LeftToRightHMM::Observation obs;

    for (Evaluators::iterator evalIt = m_gestureClassificators.begin();
            evalIt != m_gestureClassificators.end(); ++evalIt, ++gestureID) {
        obs.clear();

        for (Gesture::iterator it = m_gesture.begin(); it != m_gesture.end(); ++it) {
            obs.push_back(evalIt->first->clusterize(*it));
        }
        prop = evalIt->second->evaluate(obs);
        if (prop > maxProp) {
            maxPropGestureID = gestureID;
        }
    }
    ProcessModule::processFrameData(new IntegerFrameData(gestureID));
}

void HMMModule::trainRecordedGesture()
{
    KMeanCluster *kmean = m_gestureClassificators[m_trainGestureID].first;
    LeftToRightHMM *hmm = m_gestureClassificators[m_trainGestureID].second;

    if (kmean == NULL || hmm == NULL) {
        throw Error("KMean Clusterizer or HMM is NULL!");
    }

    std::cout << m_gesture.size() << std::endl;
    for (Gesture::iterator it = m_gesture.begin(); it != m_gesture.end(); ++it) {
        std::cout << "Vector: " << it->get(0) << " " << it->get(1) << " " << it->get(2) << std::endl;
    }

    kmean->train(m_gesture);
    LeftToRightHMM::Observation obs;
    for (Gesture::iterator it = m_gesture.begin(); it != m_gesture.end(); ++it) {
        obs.push_back(kmean->clusterize(*it));
    }
    hmm->train(obs, 10);
    // TODO: Parameter fuer iterationen anpassbar machen
}

void HMMModule::addGesure(KMeanCluster *clusterizer, LeftToRightHMM *hmm)
{
    m_gestureClassificators.push_back(std::make_pair(clusterizer, hmm));
}

bool HMMModule::serializeGesture(ConfigManager &gestureFile, std::string gestureName, int gestureId)
{
    KMeanCluster *kmean = m_gestureClassificators.at(gestureId).first;
    LeftToRightHMM *hmm = m_gestureClassificators.at(gestureId).second;

    if ((kmean == NULL) || (hmm == NULL) || gestureFile.hasSection(gestureName))
        return false;

    ConfigSection gestureSection;
    gestureSection.setItem<int>("id", gestureId);
    gestureSection.setItem<int>("clusters", kmean->getClusterCount());
    gestureSection.setItem<int>("states", hmm->getStateCount());
    gestureSection.setMatrixDouble("transition", hmm->getTransitionProps());
    gestureSection.setMatrixDouble("output", hmm->getOutputProps());

    // save KMean clusterizer
    int index = 0;
    for (KMeanCluster::VectorList::iterator it = kmean->begin(); it != kmean->end(); ++it, ++index) {
        std::string name("center_");
        name += convertTo<int, std::string>(index);
        gestureSection.setVector3d(name, *it);
    }

    gestureFile.setSection(gestureName, gestureSection);

    return true;
}

bool HMMModule::deserializeGesture(ConfigSection &section, std::string gestureName)
{
    // TODO: error handling, clear previous
    // load kmean
    int clusters = section.get<int>("clusters");
    KMeanCluster::VectorList centers;
    for (int i = 0; i < clusters; ++i) {
        centers.push_back(section.getVector3d("center_"+convertTo<int, std::string>(i)));
    }

    KMeanCluster *kmean = new KMeanCluster(clusters);
    kmean->setCentres(centers);

    // load hmm
    int states = section.get<int>("states");
    Matrix<double> transitions = section.getMatrixDouble("transition");
    Matrix<double> outputs = section.getMatrixDouble("output");

    LeftToRightHMM *hmm = new LeftToRightHMM(states, clusters);
    hmm->setTransitionProps(transitions);
    hmm->setOutputProps(outputs);

    // save in vector
    int id = section.get<int>("id");
    if (m_gestureClassificators.size() <= static_cast<size_t>(id)) {
        m_gestureClassificators.resize(id+1);
    }
    m_gestureClassificators.at(id) = std::make_pair(kmean, hmm);

    return true;
}

---