How to write modules, in which the two algorithms are performed. This
means that recorded gestures have to be loaded and then compared to a series of
sensordata, which is provided by the sensor-module (or rather: several instances of the sensor-module).The output of the classifier-modules should probably be the simple
classification-result: was a gesture recognised and which one? Here are some C++ code using this can any one please help in and send me the answer would be great helpful waiting for your positive reply.
1.
/*
* sensor.h
*
* Created on: 22.08.2013
* Author: Stieber
*/
#ifndef _SENSOR_H_
#define _SENSOR_H_
#include "systemc.h"
/*
* SystemC Class Macro
*/
SC_MODULE (Sensor) {
std::string filename; // Input File Name
bool loop;
void read_from_file()
{
bool force_exit = false; // used to exit while loop, for example, when file has ended
sc_bv<16> x_bv,y_bv,z_bv; // Input Values in 16bit Bit Vector format
sc_uint<16> x_uint, y_uint, z_uint; // Input Values in 16bit Unsigned Integer Format
while(!force_exit)
{
ifstream input_file;
input_file.open(filename.c_str());
if (input_file.is_open())
{
while (!input_file.eof())
{
// Read Sensorvalues from File (decimal LSB Format)
std::string line;
getline(input_file, line, ';'); //X
x_bv = atoi(line.c_str());
getline(input_file, line, ';'); //Y
y_bv = atoi(line.c_str());
getline(input_file, line, ';'); //Z
z_bv = atoi(line.c_str());
// optional conversion into Unsigned Integer
x_uint = x_bv.to_uint();
y_uint = y_bv.to_uint();
z_uint = z_bv.to_uint();
// print data
cout << "[" << sc_time_stamp() << "] New sensor data!" << endl;
cout << "\tX_BV: " << x_bv << " X_UINT: " << x_uint << endl;
cout << "\tY_BV: " << y_bv << " Y_UINT: " << y_uint << endl;
cout << "\tZ_BV: " << z_bv << " Z_UINT: " << z_uint << endl;
cout << endl;
//... here could the data be written to output, if connected to further modules
// never forget the wait, if simulation time should go on
wait(1,SC_MS);
}
input_file.close();
}
else
{
cout << "WARNING: No sensor data found!" << endl;
force_exit = true;
}
cout << "End of file reached." << endl;
if(!loop)
force_exit = true;
}
cout << "End of sensor input. Simulation is stopping now." << endl;
}
void setFilename(std::string _filename)
{
filename = _filename;
}
void setLoop(bool _loop)
{
loop = _loop;
}
SC_CTOR(Sensor)
: filename("sensordata.csv")
, loop(false)
{
SC_THREAD(read_from_file);
}
};
#endif /* _SENSOR_H_ */
2. sc_main.cpp
#include "systemc.h"
#include "sensor.h"
int sc_main(int argc, char* argv[])
{
std::string filename = "sensordata.csv";
bool loop = false;
if(argc > 1)
{
filename = argv[1];
}
Sensor sensor_module("Sensor");
sensor_module.setFilename(filename);
sensor_module.setLoop(loop);
/*
* start simulation
*/
sc_start();
return 0;
}
3.distance-dtw.txt file.
class sensorPoint {
public:
short accXg;
short accYg;
short accZg;
short rotXg;
short rotYg;
short rotZg;
uint accDir;
uint accLength;
//more?
sensorPoint(double X, double Y, double Z, double rotX, double rotY, double rotZ, int dir, int length):
accXg(X), accYg(Y), accZg(Z), rotXg(rotX), rotYg(rotY), rotZg(rotZ), accDir(dir), accLength(length) { }
sensorPoint(double X, double Y, double Z, int dir, int length):
accXg(X), accYg(Y), accZg(Z), rotXg(0), rotYg(0), rotZg(0), accDir(dir), accLength(length) { }
double eucDistDuo(sensorPoint &s)
{ return sqrt((accDir - s.accDir) * (accDir - s.accDir) + (accLength - s.accLength) * (accLength - s.accLength));}
double eucDistTri(sensorPoint &s)
{ return sqrt((accXg - s.accXg) * (accXg - s.accXg) + (accYg - s.accYg) * (accYg - s.accYg) + (accZg - s.accZg) * (accZg - s.accZg));}
double quant_distance(const sensorPoint);
double euclid_distance(const sensorPoint);
double linear_distance(const sensorPoint);
};
class dataPoint {
public:
string timestamp;
vector sensVec;
uint strongestSensor;
dataPoint(){
timestamp = "0";
strongestSensor = 0;
}
dataPoint(uint sensorCount){
timestamp = "0";
strongestSensor = 0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
for(uint i=0; i< sensorCount; i++)
{
sensVec.push_back(emptySensor);
}
}
dataPoint(string newTimestamp, sensorPoint &newSensorPoint)
{ timestamp = newTimestamp;
strongestSensor = 0;
sensVec.insert(sensVec.begin(),newSensorPoint);}
double euclid_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).euclid_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
double linear_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).linear_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
double quant_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).quant_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
};
double sensorPoint::euclid_distance(const sensorPoint s)
{
double sum1 = ((accXg - s.accXg) * (accXg - s.accXg) + (accYg - s.accYg) * (accYg - s.accYg) + (accZg - s.accZg) * (accZg - s.accZg));
double sum2 = ((rotXg - s.rotXg) * (rotXg - s.rotXg) + (rotYg - s.rotYg) * (rotYg - s.rotYg) + (rotZg - s.rotZg) * (rotZg - s.rotZg));
return sqrt(sum1 + sum2);
}
double sensorPoint::linear_distance(const sensorPoint s)
{
double sum1 = (abs(accXg - s.accXg) + abs(accYg - s.accYg) + abs(accZg - s.accZg));
double sum2 = (abs(rotXg - s.rotXg) + abs(rotYg - s.rotYg) + abs(rotZg - s.rotZg));
return (sum1 + sum2);
}
class VectorDTW
{
private:
vector > mGamma;
int lengthV, lengthW, mConstraint;
public:
enum { INF = 100000000 };
static inline double min (double x, double y ) { return x < y ? x : y; }
VectorDTW(uint n, uint m, uint constraint) : mGamma(n, vector(m, INF)), lengthV(n), lengthW(m), mConstraint(constraint) { }
inline double calcDTWDistanceSensor(vector &v, vector &w)
{
assert(static_cast(v.size()) >= lengthV);
assert(static_cast(w.size()) == lengthW);
assert(static_cast(mGamma.size()) == lengthV);
double cost(INF);
mConstraint = max(mConstraint, (int)fabs(lengthV-lengthW));
for (int i = 1; i < lengthV; ++i)
{
assert(static_cast(mGamma[i].size()) == lengthW);
for(int j = max(0, i - mConstraint); j < min(lengthW, i + mConstraint); ++j)
{
cost = INF;
if((i == 0) && (j == 0))
{
mGamma[i][j] = v[i].euclid_distance(w[j]);
// mGamma[i][j] = v[i].linear_distance(w[j]);
// mGamma[i][j] = v[i].quant_distance(w[j]);
}
else
{
cost = v[i].euclid_distance(w[j]);
// cost = v[i].linear_distance(w[j]);
// cost = v[i].quant_distance(w[j]);
mGamma[i][j] = cost + min(mGamma[i-1][j], min(mGamma[i][j-1], mGamma[i-1][j-1]));
}
}
}
return mGamma[lengthV-1][lengthW-1];
}
};
}
4.datafilehandler.cpp
#include "RecognitionWrapper.h"
#include "DataFileHandler.h"
#include "DataReduction.h"
#include
#include
#include
#include
using namespace std;
namespace HGR1 {
DataFileHandler::DataFileHandler() {
}
DataFileHandler::~DataFileHandler() {
}
bool DataFileHandler::readDataPoint(dataPoint *actDataPoint, string fileName, int lineNumber)
{
fstream dataFile;
dataFile.open(fileName.c_str(), ios::in);
if(dataFile)
{
actDataPoint->sensVec.clear();
string inputDataPointString;
stringstream inputDataPointStringStream;
string inputSensorString;
stringstream inputSensorStringStream;
string inputDataString[6];
dataFile.seekg(ios::beg);
for(int i=0;i< lineNumber; i++)
{
dataFile.ignore(std::numeric_limits::max(), '\n');
}
if(getline(dataFile, inputDataPointString))
{
inputDataPointStringStream.str("");
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
inputSensorStringStream.str("");
inputSensorStringStream << inputSensorString;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
actDataPoint->sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
actDataPoint->sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
actDataPoint->sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
actDataPoint->sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
actDataPoint->sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
actDataPoint->sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
}
else
{
return false;
}
dataFile.close();
return true;
}
else
{
cout << "No gesture file " << fileName << " found!" << endl;
return false;
}
}
bool DataFileHandler::readGestureData(vector *dataVector, string fileName)
{
//cout << "ReadGestureData from " << fileName << endl;
dataVector->clear();
string inputDataPointString;
string inputSensorString;
string inputDataString[6];
fstream dataFile;
dataFile.open(fileName.c_str(), ios::in);
if(dataFile)
{
while(getline(dataFile,inputDataPointString))
{
stringstream inputDataPointStringStream;
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
dataPoint latestData(" ", emptySensor);
latestData.sensVec.push_back(emptySensor);
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
stringstream inputSensorStringStream;
inputSensorStringStream << inputSensorString;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
latestData.sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
latestData.sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
latestData.sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
latestData.sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
latestData.sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
latestData.sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
dataVector->push_back(latestData);
}
dataFile.close();
return true;
}
else
{
cout << "could not open " << fileName << " !" << endl;
return false;
}
}
void DataFileHandler::scaleAccelerometerData(vector *actData)
{
double maxLength =0;
for(uint i=0; i < actData->size(); i++)
{
for(uint j=0; j < actData->at(i).sensVec.size(); j++)
{
if(actData->at(i).sensVec[j].accLength > maxLength)
{
maxLength = actData->at(i).sensVec[j].accLength;
}
}
}
if(maxLength > 0)
{
for(uint i=0; i < actData->size(); i++)
{
for(uint j=0; j < actData->at(i).sensVec.size(); j++)
{
actData->at(i).sensVec[j].accXg = (actData->at(i).sensVec[j].accXg / maxLength)*32767;
actData->at(i).sensVec[j].accYg = (actData->at(i).sensVec[j].accYg / maxLength)*32767;
actData->at(i).sensVec[j].accZg = (actData->at(i).sensVec[j].accZg / maxLength)*32767;
}
}
}
}
bool DataFileHandler::getLearnedGesturesDTW(vector > *gestureList, vector *gestureNames)
{
//cout << "getLearnedGesturesDTW" << endl;
gestureList->clear();
gestureNames->clear();
string inputString;
fstream listFile;
listFile.open("gesturelistDTW.list", ios::in);
if(listFile)
{
while(getline(listFile,inputString))
{
string dataFile = inputString;
vector emptyVector;
gestureList->push_back(emptyVector);
if(readGestureData(&(gestureList->back()),dataFile))
{
gestureNames->push_back(dataFile);
}
else
{
gestureList->pop_back();
}
}
listFile.close();
return true;
}
else
{
cout << "No gesturelistDTW.list found!" << endl;
return false;
}
}
bool DataFileHandler::getLearnedGesturesHMM(vector *gestureNames)
{
//cout << "getLearnedGesturesHMM" << endl;
gestureNames->clear();
string inputString;
fstream listFile;
listFile.open("gesturelistHMM.list", ios::in);
if(listFile)
{
while(getline(listFile,inputString))
{
string dataFile = inputString;
gestureNames->push_back(dataFile);
}
listFile.close();
return true;
}
else
{
cout << "No gesturelistHMM.list found!" << endl;
return false;
}
}
bool DataFileHandler::getLearnedGesturesStatic(vector *gestureList, vector *gestureNameList)
{
//UNDER CONSTRUCTION
string inputDataPointString;
string inputSensorString;
string inputDataString[6];
fstream dataFile;
dataFile.open("gesturelistStatic.list", ios::in);
if(dataFile)
{
while(getline(dataFile,inputDataPointString))
{
stringstream inputDataPointStringStream;
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
dataPoint latestData(" ", emptySensor);
// HERE assumption that there are only two sensors
latestData.sensVec.push_back(emptySensor);
string gestureName;
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
stringstream inputSensorStringStream;
inputSensorStringStream << inputSensorString;
// therefore i assume the same here
if(sensorCounter == 2)
{
gestureName = inputSensorString;
//cout << " gesture name = " << gestureName << endl;
}
else
{
//cout << sensorCounter;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
latestData.sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
latestData.sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
latestData.sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
latestData.sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
latestData.sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
latestData.sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
}
gestureList->push_back(latestData);
gestureNameList->push_back(gestureName);
}
dataFile.close();
return true;
}
else
{
cout << "could not open gesturelistStatic.list!" << endl;
return false;
}
return false;
}
bool DataFileHandler::getRecordedGestures(vector *gestureNames, vector > *gestureFiles)
{
//cout << "getRecordedGestures" << endl;
gestureFiles->clear();
gestureNames->clear();
string inputString;
fstream gestListFile;
gestListFile.open("gestRecNames.list", ios::in);
if(gestListFile)
{
while(getline(gestListFile,inputString))
{
string dataListFileName = inputString;
gestureNames->push_back(dataListFileName);
vector fileVector;
string inputFileString;
fstream dataListFile;
dataListFile.open((dataListFileName + ".list").c_str(), ios::in);
if(dataListFile)
{
while(getline(dataListFile,inputFileString))
{
fileVector.push_back(inputFileString);
}
dataListFile.close();
}
gestureFiles->push_back(fileVector);
}
gestListFile.close();
return true;
}
else
{
cout << "No gestRecNames.list found, creating..." << endl;
gestListFile.open("gestRecNames.list", ios::out|ios::app);
if(gestListFile)
{
return true;
}
else
{
return false;
}
}
}
bool DataFileHandler::getRecordedTestdata(vector *fileList)
{
//cout << "getRecordedTestdata" << endl;
fileList->clear();
fstream testListFile;
string inputString;
testListFile.open("testRecNames.list", ios::in);
if(testListFile)
{
while(getline(testListFile,inputString))
{
string dataFileName = inputString;
fileList->push_back(dataFileName);
}
testListFile.close();
return true;
}
else
{
cout << "No testRecNames.list found!" << endl;
return false;
}
}
void DataFileHandler::getRecordFileName(string *recordFile)
{
//cout << "getRecordFileName" << recordFile;
vector testDataList;
if(getRecordedTestdata(&testDataList))
{
for(uint i = 0; i< testDataList.size(); i++)
{
if(recordFile->compare(testDataList.at(i)) == 0)
{
recordFile->insert((recordFile->size() -4), "1");
}
}
cout << " new:" << recordFile << endl;
fstream listFile;
listFile.open("testRecNames.list", ios::out|ios::app);
if(listFile)
{
listFile << recordFile->c_str();
listFile << endl;
listFile.close();
}
else
{
cout << "Cannot open recording list file" << endl;
}
}
}
void DataFileHandler::getRecordFileName(string *recordFile, string *gestureName)
{
//cout << "getRecordFileName gesture " << gestureName->c_str() << endl;
vector gestList;
vector > gestureFiles;
stringstream fileNameStream;
int gestureID = -1;
if(getRecordedGestures(&gestList,&gestureFiles))
{
for(uint i=0; i < gestList.size(); i++)
{
if(gestureName->compare(gestList.at(i)) ==0)
{
gestureID = i;
recordFile->clear();
fileNameStream << gestureName->c_str() << gestureFiles.at(i).size() << ".rec";
recordFile->append(fileNameStream.str());
}
}
if(gestureID == -1)
{
recordFile->clear();
recordFile->append(*gestureName);
recordFile->append("0.rec");
fstream gestureListFile;
gestureListFile.open("gestRecNames.list", ios::out|ios::app);
if(gestureListFile)
{
gestureListFile << gestureName->c_str();
gestureListFile << endl;
gestureListFile.close();
}
else
{
cout << "Cannot open gesture list file" << endl;
}
}
fstream fileListFile;
string gestureString = *gestureName;
gestureString += ".list";
fileListFile.open(gestureString.c_str(), ios::out|ios::app);
if(fileListFile)
{
fileListFile << recordFile->c_str();
fileListFile << endl;
fileListFile.close();
}
else
{
cout << "Cannot open recording list file" << endl;
}
}
}
void DataFileHandler::learnGesture(vector *dataVector, string gestureName)
{
string inputString;
string activeGestureName = "none";
int gestureCounter =0;
fstream listFile;
listFile.open("gesturelistDTW.list", fstream::in|fstream::out|fstream::app);
if(listFile)
{
while(getline(listFile,inputString))
{
cout << inputString << endl;
activeGestureName = inputString;
if(activeGestureName.compare(0,gestureName.size(),gestureName) == 0)
{
gestureCounter++;
}
}
listFile.close();
}
listFile.clear();
stringstream fileNameStream;
fileNameStream << gestureName << gestureCounter << ".gest";
string fileName = fileNameStream.str();
writeDataFile(dataVector, fileName);
listFile.open("gesturelistDTW.list", ios::out|ios::app);
if(listFile)
{
listFile << fileName << endl;
listFile.close();
}
else
{
cout << "could not open gesturelist.list!" << endl;
}
}
void DataFileHandler::learnGestureStatic(dataPoint *actDataPoint, string learnName)
{
//UNDER CONSTRUCTION
fstream learnFile;
learnFile.open("gesturelistStatic.list", ios::out|ios::app);
if(learnFile)
{
for(uint j=0; j< actDataPoint->sensVec.size(); j++)
{
learnFile << actDataPoint->sensVec[j].accXg;
learnFile << "," << actDataPoint->sensVec[j].accYg;
learnFile << "," << actDataPoint->sensVec[j].accZg;
learnFile << "," << actDataPoint->sensVec[j].rotXg;
learnFile << "," << actDataPoint->sensVec[j].rotYg;
learnFile << "," << actDataPoint->sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << learnName << ";" << endl;
learnFile.close();
}
}
void DataFileHandler::writeDataPoint(dataPoint *actDataPoint, string fileName)
{
fstream learnFile;
learnFile.open(fileName.c_str(), ios::out|ios::app);
if(learnFile)
{
// cout << "writing datapoint!" << endl;
// here for-loop with further temporal coarsening
for(uint j=0; j< actDataPoint->sensVec.size(); j++)
{
learnFile << actDataPoint->sensVec[j].accXg;
learnFile << "," << actDataPoint->sensVec[j].accYg;
learnFile << "," << actDataPoint->sensVec[j].accZg;
learnFile << "," << actDataPoint->sensVec[j].rotXg;
learnFile << "," << actDataPoint->sensVec[j].rotYg;
learnFile << "," << actDataPoint->sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << endl;
learnFile.close();
}
else
{
cout << "cannot open file to record to" << endl;
}
}
void DataFileHandler::writeDataFile(vector *gestureData, string fileName)
{
scaleAccelerometerData(gestureData);
//cout << "writeDataFile " << fileName << endl;
fstream learnFile;
learnFile.open(fileName.c_str(), ios::out|ios::app);
if(learnFile)
{
learnFile.clear();
for(int i=0; i < (int)gestureData->size(); i++)
{
for(uint j=0; j< gestureData->at(i).sensVec.size(); j++)
{
learnFile << gestureData->at(i).sensVec[j].accXg;
learnFile << "," << gestureData->at(i).sensVec[j].accYg;
learnFile << "," << gestureData->at(i).sensVec[j].accZg;
learnFile << "," << gestureData->at(i).sensVec[j].rotXg;
learnFile << "," << gestureData->at(i).sensVec[j].rotYg;
learnFile << "," << gestureData->at(i).sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << endl;
}
learnFile.close();
}
}
}
5.classifierone.cpp file
#include "ClassifierOne.h"
#include "PresentOne.h"
#include "RecognitionWrapper.h"
#include "DataFileHandler.h"
using namespace std;
namespace HGR1 {
ClassifierOne::ClassifierOne(RecognitionWrapper *actWrapper)
{
scaling = true;
//scaling = false;
gestureList = new vector >;
gestureNameList = new vector;
scaledData = new vector;
if(actWrapper->dataFileHandler->getLearnedGesturesDTW(gestureList, gestureNameList))
{
cout << "Successfully loaded " << gestureList->size() << " gestures!" << endl;
//scaling
if(scaling)
{
for(uint l=0; l < gestureList->size(); l++)
{
double maxLength =0;
actWrapper->dataReduction->calcLengthDir(&(gestureList->at(l)));
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
if(gestureList->at(l).at(i).sensVec[j].accLength > maxLength)
{
maxLength = gestureList->at(l).at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
gestureList->at(l).at(i).sensVec[j].accXg = (gestureList->at(l).at(i).sensVec[j].accXg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accYg = (gestureList->at(l).at(i).sensVec[j].accYg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accZg = (gestureList->at(l).at(i).sensVec[j].accZg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].rotXg = gestureList->at(l).at(i).sensVec[j].rotXg;
gestureList->at(l).at(i).sensVec[j].rotYg = gestureList->at(l).at(i).sensVec[j].rotYg;
gestureList->at(l).at(i).sensVec[j].rotZg = gestureList->at(l).at(i).sensVec[j].rotZg;
gestureList->at(l).at(i).sensVec[j].accDir = gestureList->at(l).at(i).sensVec[j].accDir;
gestureList->at(l).at(i).sensVec[j].accLength = (gestureList->at(l).at(i).sensVec[j].accLength / maxLength)*32767;
}
}
}
}
}
}
}
ClassifierOne::~ClassifierOne() {
// TODO Auto-generated destructor stub
}
int ClassifierOne::run(RecognitionWrapper* actWrapper)
{
if(actWrapper->accData->timeSeries.size() == vectorLength)
{
//scaling
if(scaling)
{
double maxLength =0;
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
if(actWrapper->accData->timeSeries.at(i).sensVec[j].accLength > maxLength)
{
maxLength = actWrapper->accData->timeSeries.at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
dataPoint scaledDataPoint(actWrapper->accData->timeSeries.at(i).sensVec.size());
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
scaledDataPoint.sensVec[j].accXg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accXg / maxLength)*32767;
scaledDataPoint.sensVec[j].accYg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accYg / maxLength)*32767;
scaledDataPoint.sensVec[j].accZg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accZg / maxLength)*32767;
scaledDataPoint.sensVec[j].rotXg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotXg;
scaledDataPoint.sensVec[j].rotYg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotYg;
scaledDataPoint.sensVec[j].rotZg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotZg;
scaledDataPoint.sensVec[j].accDir = actWrapper->accData->timeSeries.at(i).sensVec[j].accDir;
scaledDataPoint.sensVec[j].accLength = (actWrapper->accData->timeSeries.at(i).sensVec[j].accLength / maxLength)*32767;
}
scaledData->push_back(scaledDataPoint);
}
}
}
int minDistGesture =0;
double distance =0;
double minDistance =100000000;
if(gestureList->size() > 0)
{
for(uint i=0; isize(); i++)
{
distance = 0;
for(uint j=0; j < gestureList->at(i).size(); j++)
{
if(scaling)
{
distance += gestureList->at(i)[j].euclid_distance(scaledData->at(j));
// distance += gestureList->at(i)[j].linear_distance(scaledData->at(j));
// distance += gestureList->at(i)[j].quant_distance(scaledData->at(j));
}
else
{
distance += gestureList->at(i)[j].euclid_distance(actWrapper->accData->timeSeries.at(j));
// distance += gestureList->at(i)[j].linear_distance(actWrapper->accData->timeSeries.at(j));
// distance += gestureList->at(i)[j].quant_distance(actWrapper->accData->timeSeries.at(j));
}
}
//cout << "distance = " << distance << endl;
if(distance < minDistance)
{
minDistance = distance;
minDistGesture = i;
}
}
}
//for Debug purposes:
//cout << "Minimal Distance is " << minDistance << " for gesture " << gestureNameList->at(minDistGesture) << " !" << endl;
if(minDistance < 140000) // this value is subject to change!
{
cout << "Easy most likely gesture: " << gestureNameList->at(minDistGesture) << " with " << minDistance << endl;
//winner takes all
}
return minDistGesture;
}
return 0;
}
void ClassifierOne::learnGesture(RecognitionWrapper *actWrapper, string learnName)
{
actWrapper->dataFileHandler->learnGesture(&(actWrapper->accData->timeSeries), learnName);
} }
6.classifierdtw.cpp file
#include "ClassifierDTW.h"
#include "vectordtw.h"
#include "DataFileHandler.h"
namespace HGR1 {
ClassifierDTW::ClassifierDTW(RecognitionWrapper* actWrapper)
{
scaling = true;
//scaling = false;
gestureList = new vector >;
gestureNameList = new vector;
scaledData = new vector;
if(actWrapper->dataFileHandler->getLearnedGesturesDTW(gestureList, gestureNameList))
{
cout << "Successfully loaded " << gestureList->size() << " gestures!" << endl;
//scaling
if(scaling)
{
for(uint l=0; l < gestureList->size(); l++)
{
double maxLength =0;
actWrapper->dataReduction->calcLengthDir(&(gestureList->at(l)));
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
if(gestureList->at(l).at(i).sensVec[j].accLength > maxLength)
{
maxLength = gestureList->at(l).at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
gestureList->at(l).at(i).sensVec[j].accXg = (gestureList->at(l).at(i).sensVec[j].accXg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accYg = (gestureList->at(l).at(i).sensVec[j].accYg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accZg = (gestureList->at(l).at(i).sensVec[j].accZg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].rotXg = gestureList->at(l).at(i).sensVec[j].rotXg;
gestureList->at(l).at(i).sensVec[j].rotYg = gestureList->at(l).at(i).sensVec[j].rotYg;
gestureList->at(l).at(i).sensVec[j].rotZg = gestureList->at(l).at(i).sensVec[j].rotZg;
gestureList->at(l).at(i).sensVec[j].accDir = gestureList->at(l).at(i).sensVec[j].accDir;
gestureList->at(l).at(i).sensVec[j].accLength = (gestureList->at(l).at(i).sensVec[j].accLength / maxLength)*32767;
}
}
}
}
}
}
}
ClassifierDTW::~ClassifierDTW()
{
}
int ClassifierDTW::run(RecognitionWrapper* actWrapper)
{
if(actWrapper->accData->timeSeries.size() == vectorLength)
{
//scaling
if(scaling)
{
double maxLength =0;
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
if(actWrapper->accData->timeSeries.at(i).sensVec[j].accLength > maxLength)
{
maxLength = actWrapper->accData->timeSeries.at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
dataPoint scaledDataPoint(actWrapper->accData->timeSeries.at(i).sensVec.size());
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
scaledDataPoint.sensVec[j].accXg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accXg / maxLength)*32767;
scaledDataPoint.sensVec[j].accYg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accYg / maxLength)*32767;
scaledDataPoint.sensVec[j].accZg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accZg / maxLength)*32767;
scaledDataPoint.sensVec[j].rotXg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotXg;
scaledDataPoint.sensVec[j].rotYg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotYg;
scaledDataPoint.sensVec[j].rotZg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotZg;
scaledDataPoint.sensVec[j].accDir = actWrapper->accData->timeSeries.at(i).sensVec[j].accDir;
scaledDataPoint.sensVec[j].accLength = (actWrapper->accData->timeSeries.at(i).sensVec[j].accLength / maxLength)*32767;
}
scaledData->push_back(scaledDataPoint);
}
}
}
//actWrapper->actResult.resultDTW = NONEDTW;
VectorDTW dtw1(actWrapper->accData->timeSeries.size(), actWrapper->accData->timeSeries.size(), 6);
int minDistGesture =0;
double distance =0;
double minDistance =100000000;
if(gestureList->size() > 0)
{
for(uint i=0; isize(); i++)
{
if(scaling)
{
distance = dtw1.calcDTWDistanceSensor(*scaledData, gestureList->at(i));
}
else
{
distance = dtw1.calcDTWDistanceSensor(actWrapper->accData->timeSeries, gestureList->at(i));
}
//cout << "distance = " << distance << endl;
if(distance < minDistance)
{
minDistance = distance;
minDistGesture = i;
}
}
}
//for Debug purposes:
//cout << "Minimal Distance is " << minDistance << " for gesture " << gestureNameList->at(minDistGesture) << " !" << endl;
if(minDistance < 140000) // this value is subject to change!
{
cout << "DTW most likely gesture: " << gestureNameList->at(minDistGesture) << " with " << minDistance << endl;
//winner takes all
}
return minDistGesture;
}
return 0;
}
void ClassifierDTW::learnGesture(RecognitionWrapper *actWrapper, string learnName)
{
actWrapper->dataFileHandler->learnGesture(&(actWrapper->accData->timeSeries), learnName);
//cout << "Learned gesture " << learnName << endl;
}
}
means that recorded gestures have to be loaded and then compared to a series of
sensordata, which is provided by the sensor-module (or rather: several instances of the sensor-module).The output of the classifier-modules should probably be the simple
classification-result: was a gesture recognised and which one? Here are some C++ code using this can any one please help in and send me the answer would be great helpful waiting for your positive reply.
1.
/*
* sensor.h
*
* Created on: 22.08.2013
* Author: Stieber
*/
#ifndef _SENSOR_H_
#define _SENSOR_H_
#include "systemc.h"
/*
* SystemC Class Macro
*/
SC_MODULE (Sensor) {
std::string filename; // Input File Name
bool loop;
void read_from_file()
{
bool force_exit = false; // used to exit while loop, for example, when file has ended
sc_bv<16> x_bv,y_bv,z_bv; // Input Values in 16bit Bit Vector format
sc_uint<16> x_uint, y_uint, z_uint; // Input Values in 16bit Unsigned Integer Format
while(!force_exit)
{
ifstream input_file;
input_file.open(filename.c_str());
if (input_file.is_open())
{
while (!input_file.eof())
{
// Read Sensorvalues from File (decimal LSB Format)
std::string line;
getline(input_file, line, ';'); //X
x_bv = atoi(line.c_str());
getline(input_file, line, ';'); //Y
y_bv = atoi(line.c_str());
getline(input_file, line, ';'); //Z
z_bv = atoi(line.c_str());
// optional conversion into Unsigned Integer
x_uint = x_bv.to_uint();
y_uint = y_bv.to_uint();
z_uint = z_bv.to_uint();
// print data
cout << "[" << sc_time_stamp() << "] New sensor data!" << endl;
cout << "\tX_BV: " << x_bv << " X_UINT: " << x_uint << endl;
cout << "\tY_BV: " << y_bv << " Y_UINT: " << y_uint << endl;
cout << "\tZ_BV: " << z_bv << " Z_UINT: " << z_uint << endl;
cout << endl;
//... here could the data be written to output, if connected to further modules
// never forget the wait, if simulation time should go on
wait(1,SC_MS);
}
input_file.close();
}
else
{
cout << "WARNING: No sensor data found!" << endl;
force_exit = true;
}
cout << "End of file reached." << endl;
if(!loop)
force_exit = true;
}
cout << "End of sensor input. Simulation is stopping now." << endl;
}
void setFilename(std::string _filename)
{
filename = _filename;
}
void setLoop(bool _loop)
{
loop = _loop;
}
SC_CTOR(Sensor)
: filename("sensordata.csv")
, loop(false)
{
SC_THREAD(read_from_file);
}
};
#endif /* _SENSOR_H_ */
2. sc_main.cpp
#include "systemc.h"
#include "sensor.h"
int sc_main(int argc, char* argv[])
{
std::string filename = "sensordata.csv";
bool loop = false;
if(argc > 1)
{
filename = argv[1];
}
Sensor sensor_module("Sensor");
sensor_module.setFilename(filename);
sensor_module.setLoop(loop);
/*
* start simulation
*/
sc_start();
return 0;
}
3.distance-dtw.txt file.
class sensorPoint {
public:
short accXg;
short accYg;
short accZg;
short rotXg;
short rotYg;
short rotZg;
uint accDir;
uint accLength;
//more?
sensorPoint(double X, double Y, double Z, double rotX, double rotY, double rotZ, int dir, int length):
accXg(X), accYg(Y), accZg(Z), rotXg(rotX), rotYg(rotY), rotZg(rotZ), accDir(dir), accLength(length) { }
sensorPoint(double X, double Y, double Z, int dir, int length):
accXg(X), accYg(Y), accZg(Z), rotXg(0), rotYg(0), rotZg(0), accDir(dir), accLength(length) { }
double eucDistDuo(sensorPoint &s)
{ return sqrt((accDir - s.accDir) * (accDir - s.accDir) + (accLength - s.accLength) * (accLength - s.accLength));}
double eucDistTri(sensorPoint &s)
{ return sqrt((accXg - s.accXg) * (accXg - s.accXg) + (accYg - s.accYg) * (accYg - s.accYg) + (accZg - s.accZg) * (accZg - s.accZg));}
double quant_distance(const sensorPoint);
double euclid_distance(const sensorPoint);
double linear_distance(const sensorPoint);
};
class dataPoint {
public:
string timestamp;
vector sensVec;
uint strongestSensor;
dataPoint(){
timestamp = "0";
strongestSensor = 0;
}
dataPoint(uint sensorCount){
timestamp = "0";
strongestSensor = 0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
for(uint i=0; i< sensorCount; i++)
{
sensVec.push_back(emptySensor);
}
}
dataPoint(string newTimestamp, sensorPoint &newSensorPoint)
{ timestamp = newTimestamp;
strongestSensor = 0;
sensVec.insert(sensVec.begin(),newSensorPoint);}
double euclid_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).euclid_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
double linear_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).linear_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
double quant_distance(const dataPoint &s)
{ double dist =0;
if(!sensVec.empty())
{for (int i =0; i < (int)sensVec.size(); ++i)
{
dist += sensVec.at(i).quant_distance(s.sensVec.at(i));
//cout << "i=" << i << " dist=" << dist << " ";
}
}
return dist;
}
};
double sensorPoint::euclid_distance(const sensorPoint s)
{
double sum1 = ((accXg - s.accXg) * (accXg - s.accXg) + (accYg - s.accYg) * (accYg - s.accYg) + (accZg - s.accZg) * (accZg - s.accZg));
double sum2 = ((rotXg - s.rotXg) * (rotXg - s.rotXg) + (rotYg - s.rotYg) * (rotYg - s.rotYg) + (rotZg - s.rotZg) * (rotZg - s.rotZg));
return sqrt(sum1 + sum2);
}
double sensorPoint::linear_distance(const sensorPoint s)
{
double sum1 = (abs(accXg - s.accXg) + abs(accYg - s.accYg) + abs(accZg - s.accZg));
double sum2 = (abs(rotXg - s.rotXg) + abs(rotYg - s.rotYg) + abs(rotZg - s.rotZg));
return (sum1 + sum2);
}
class VectorDTW
{
private:
vector > mGamma;
int lengthV, lengthW, mConstraint;
public:
enum { INF = 100000000 };
static inline double min (double x, double y ) { return x < y ? x : y; }
VectorDTW(uint n, uint m, uint constraint) : mGamma(n, vector(m, INF)), lengthV(n), lengthW(m), mConstraint(constraint) { }
inline double calcDTWDistanceSensor(vector &v, vector &w)
{
assert(static_cast(v.size()) >= lengthV);
assert(static_cast(w.size()) == lengthW);
assert(static_cast(mGamma.size()) == lengthV);
double cost(INF);
mConstraint = max(mConstraint, (int)fabs(lengthV-lengthW));
for (int i = 1; i < lengthV; ++i)
{
assert(static_cast(mGamma[i].size()) == lengthW);
for(int j = max(0, i - mConstraint); j < min(lengthW, i + mConstraint); ++j)
{
cost = INF;
if((i == 0) && (j == 0))
{
mGamma[i][j] = v[i].euclid_distance(w[j]);
// mGamma[i][j] = v[i].linear_distance(w[j]);
// mGamma[i][j] = v[i].quant_distance(w[j]);
}
else
{
cost = v[i].euclid_distance(w[j]);
// cost = v[i].linear_distance(w[j]);
// cost = v[i].quant_distance(w[j]);
mGamma[i][j] = cost + min(mGamma[i-1][j], min(mGamma[i][j-1], mGamma[i-1][j-1]));
}
}
}
return mGamma[lengthV-1][lengthW-1];
}
};
}
4.datafilehandler.cpp
#include "RecognitionWrapper.h"
#include "DataFileHandler.h"
#include "DataReduction.h"
#include
#include
#include
#include
using namespace std;
namespace HGR1 {
DataFileHandler::DataFileHandler() {
}
DataFileHandler::~DataFileHandler() {
}
bool DataFileHandler::readDataPoint(dataPoint *actDataPoint, string fileName, int lineNumber)
{
fstream dataFile;
dataFile.open(fileName.c_str(), ios::in);
if(dataFile)
{
actDataPoint->sensVec.clear();
string inputDataPointString;
stringstream inputDataPointStringStream;
string inputSensorString;
stringstream inputSensorStringStream;
string inputDataString[6];
dataFile.seekg(ios::beg);
for(int i=0;i< lineNumber; i++)
{
dataFile.ignore(std::numeric_limits::max(), '\n');
}
if(getline(dataFile, inputDataPointString))
{
inputDataPointStringStream.str("");
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
inputSensorStringStream.str("");
inputSensorStringStream << inputSensorString;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
actDataPoint->sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
actDataPoint->sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
actDataPoint->sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
actDataPoint->sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
actDataPoint->sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
actDataPoint->sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
}
else
{
return false;
}
dataFile.close();
return true;
}
else
{
cout << "No gesture file " << fileName << " found!" << endl;
return false;
}
}
bool DataFileHandler::readGestureData(vector *dataVector, string fileName)
{
//cout << "ReadGestureData from " << fileName << endl;
dataVector->clear();
string inputDataPointString;
string inputSensorString;
string inputDataString[6];
fstream dataFile;
dataFile.open(fileName.c_str(), ios::in);
if(dataFile)
{
while(getline(dataFile,inputDataPointString))
{
stringstream inputDataPointStringStream;
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
dataPoint latestData(" ", emptySensor);
latestData.sensVec.push_back(emptySensor);
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
stringstream inputSensorStringStream;
inputSensorStringStream << inputSensorString;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
latestData.sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
latestData.sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
latestData.sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
latestData.sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
latestData.sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
latestData.sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
dataVector->push_back(latestData);
}
dataFile.close();
return true;
}
else
{
cout << "could not open " << fileName << " !" << endl;
return false;
}
}
void DataFileHandler::scaleAccelerometerData(vector *actData)
{
double maxLength =0;
for(uint i=0; i < actData->size(); i++)
{
for(uint j=0; j < actData->at(i).sensVec.size(); j++)
{
if(actData->at(i).sensVec[j].accLength > maxLength)
{
maxLength = actData->at(i).sensVec[j].accLength;
}
}
}
if(maxLength > 0)
{
for(uint i=0; i < actData->size(); i++)
{
for(uint j=0; j < actData->at(i).sensVec.size(); j++)
{
actData->at(i).sensVec[j].accXg = (actData->at(i).sensVec[j].accXg / maxLength)*32767;
actData->at(i).sensVec[j].accYg = (actData->at(i).sensVec[j].accYg / maxLength)*32767;
actData->at(i).sensVec[j].accZg = (actData->at(i).sensVec[j].accZg / maxLength)*32767;
}
}
}
}
bool DataFileHandler::getLearnedGesturesDTW(vector > *gestureList, vector *gestureNames)
{
//cout << "getLearnedGesturesDTW" << endl;
gestureList->clear();
gestureNames->clear();
string inputString;
fstream listFile;
listFile.open("gesturelistDTW.list", ios::in);
if(listFile)
{
while(getline(listFile,inputString))
{
string dataFile = inputString;
vector emptyVector;
gestureList->push_back(emptyVector);
if(readGestureData(&(gestureList->back()),dataFile))
{
gestureNames->push_back(dataFile);
}
else
{
gestureList->pop_back();
}
}
listFile.close();
return true;
}
else
{
cout << "No gesturelistDTW.list found!" << endl;
return false;
}
}
bool DataFileHandler::getLearnedGesturesHMM(vector *gestureNames)
{
//cout << "getLearnedGesturesHMM" << endl;
gestureNames->clear();
string inputString;
fstream listFile;
listFile.open("gesturelistHMM.list", ios::in);
if(listFile)
{
while(getline(listFile,inputString))
{
string dataFile = inputString;
gestureNames->push_back(dataFile);
}
listFile.close();
return true;
}
else
{
cout << "No gesturelistHMM.list found!" << endl;
return false;
}
}
bool DataFileHandler::getLearnedGesturesStatic(vector *gestureList, vector *gestureNameList)
{
//UNDER CONSTRUCTION
string inputDataPointString;
string inputSensorString;
string inputDataString[6];
fstream dataFile;
dataFile.open("gesturelistStatic.list", ios::in);
if(dataFile)
{
while(getline(dataFile,inputDataPointString))
{
stringstream inputDataPointStringStream;
inputDataPointStringStream << inputDataPointString;
int sensorCounter =0;
sensorPoint emptySensor(0,0,0,0,0,0,0,0);
dataPoint latestData(" ", emptySensor);
// HERE assumption that there are only two sensors
latestData.sensVec.push_back(emptySensor);
string gestureName;
while(getline(inputDataPointStringStream,inputSensorString,';'))
{
stringstream inputSensorStringStream;
inputSensorStringStream << inputSensorString;
// therefore i assume the same here
if(sensorCounter == 2)
{
gestureName = inputSensorString;
//cout << " gesture name = " << gestureName << endl;
}
else
{
//cout << sensorCounter;
for(int i =0; i<6; i++)
{
getline(inputSensorStringStream,inputDataString[i],',');
}
latestData.sensVec[sensorCounter].accXg = atof(inputDataString[0].c_str());
latestData.sensVec[sensorCounter].accYg = atof(inputDataString[1].c_str());
latestData.sensVec[sensorCounter].accZg = atof(inputDataString[2].c_str());
latestData.sensVec[sensorCounter].rotXg = atof(inputDataString[3].c_str());
latestData.sensVec[sensorCounter].rotYg = atof(inputDataString[4].c_str());
latestData.sensVec[sensorCounter].rotZg = atof(inputDataString[5].c_str());
sensorCounter++;
}
}
gestureList->push_back(latestData);
gestureNameList->push_back(gestureName);
}
dataFile.close();
return true;
}
else
{
cout << "could not open gesturelistStatic.list!" << endl;
return false;
}
return false;
}
bool DataFileHandler::getRecordedGestures(vector *gestureNames, vector > *gestureFiles)
{
//cout << "getRecordedGestures" << endl;
gestureFiles->clear();
gestureNames->clear();
string inputString;
fstream gestListFile;
gestListFile.open("gestRecNames.list", ios::in);
if(gestListFile)
{
while(getline(gestListFile,inputString))
{
string dataListFileName = inputString;
gestureNames->push_back(dataListFileName);
vector fileVector;
string inputFileString;
fstream dataListFile;
dataListFile.open((dataListFileName + ".list").c_str(), ios::in);
if(dataListFile)
{
while(getline(dataListFile,inputFileString))
{
fileVector.push_back(inputFileString);
}
dataListFile.close();
}
gestureFiles->push_back(fileVector);
}
gestListFile.close();
return true;
}
else
{
cout << "No gestRecNames.list found, creating..." << endl;
gestListFile.open("gestRecNames.list", ios::out|ios::app);
if(gestListFile)
{
return true;
}
else
{
return false;
}
}
}
bool DataFileHandler::getRecordedTestdata(vector *fileList)
{
//cout << "getRecordedTestdata" << endl;
fileList->clear();
fstream testListFile;
string inputString;
testListFile.open("testRecNames.list", ios::in);
if(testListFile)
{
while(getline(testListFile,inputString))
{
string dataFileName = inputString;
fileList->push_back(dataFileName);
}
testListFile.close();
return true;
}
else
{
cout << "No testRecNames.list found!" << endl;
return false;
}
}
void DataFileHandler::getRecordFileName(string *recordFile)
{
//cout << "getRecordFileName" << recordFile;
vector testDataList;
if(getRecordedTestdata(&testDataList))
{
for(uint i = 0; i< testDataList.size(); i++)
{
if(recordFile->compare(testDataList.at(i)) == 0)
{
recordFile->insert((recordFile->size() -4), "1");
}
}
cout << " new:" << recordFile << endl;
fstream listFile;
listFile.open("testRecNames.list", ios::out|ios::app);
if(listFile)
{
listFile << recordFile->c_str();
listFile << endl;
listFile.close();
}
else
{
cout << "Cannot open recording list file" << endl;
}
}
}
void DataFileHandler::getRecordFileName(string *recordFile, string *gestureName)
{
//cout << "getRecordFileName gesture " << gestureName->c_str() << endl;
vector gestList;
vector > gestureFiles;
stringstream fileNameStream;
int gestureID = -1;
if(getRecordedGestures(&gestList,&gestureFiles))
{
for(uint i=0; i < gestList.size(); i++)
{
if(gestureName->compare(gestList.at(i)) ==0)
{
gestureID = i;
recordFile->clear();
fileNameStream << gestureName->c_str() << gestureFiles.at(i).size() << ".rec";
recordFile->append(fileNameStream.str());
}
}
if(gestureID == -1)
{
recordFile->clear();
recordFile->append(*gestureName);
recordFile->append("0.rec");
fstream gestureListFile;
gestureListFile.open("gestRecNames.list", ios::out|ios::app);
if(gestureListFile)
{
gestureListFile << gestureName->c_str();
gestureListFile << endl;
gestureListFile.close();
}
else
{
cout << "Cannot open gesture list file" << endl;
}
}
fstream fileListFile;
string gestureString = *gestureName;
gestureString += ".list";
fileListFile.open(gestureString.c_str(), ios::out|ios::app);
if(fileListFile)
{
fileListFile << recordFile->c_str();
fileListFile << endl;
fileListFile.close();
}
else
{
cout << "Cannot open recording list file" << endl;
}
}
}
void DataFileHandler::learnGesture(vector *dataVector, string gestureName)
{
string inputString;
string activeGestureName = "none";
int gestureCounter =0;
fstream listFile;
listFile.open("gesturelistDTW.list", fstream::in|fstream::out|fstream::app);
if(listFile)
{
while(getline(listFile,inputString))
{
cout << inputString << endl;
activeGestureName = inputString;
if(activeGestureName.compare(0,gestureName.size(),gestureName) == 0)
{
gestureCounter++;
}
}
listFile.close();
}
listFile.clear();
stringstream fileNameStream;
fileNameStream << gestureName << gestureCounter << ".gest";
string fileName = fileNameStream.str();
writeDataFile(dataVector, fileName);
listFile.open("gesturelistDTW.list", ios::out|ios::app);
if(listFile)
{
listFile << fileName << endl;
listFile.close();
}
else
{
cout << "could not open gesturelist.list!" << endl;
}
}
void DataFileHandler::learnGestureStatic(dataPoint *actDataPoint, string learnName)
{
//UNDER CONSTRUCTION
fstream learnFile;
learnFile.open("gesturelistStatic.list", ios::out|ios::app);
if(learnFile)
{
for(uint j=0; j< actDataPoint->sensVec.size(); j++)
{
learnFile << actDataPoint->sensVec[j].accXg;
learnFile << "," << actDataPoint->sensVec[j].accYg;
learnFile << "," << actDataPoint->sensVec[j].accZg;
learnFile << "," << actDataPoint->sensVec[j].rotXg;
learnFile << "," << actDataPoint->sensVec[j].rotYg;
learnFile << "," << actDataPoint->sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << learnName << ";" << endl;
learnFile.close();
}
}
void DataFileHandler::writeDataPoint(dataPoint *actDataPoint, string fileName)
{
fstream learnFile;
learnFile.open(fileName.c_str(), ios::out|ios::app);
if(learnFile)
{
// cout << "writing datapoint!" << endl;
// here for-loop with further temporal coarsening
for(uint j=0; j< actDataPoint->sensVec.size(); j++)
{
learnFile << actDataPoint->sensVec[j].accXg;
learnFile << "," << actDataPoint->sensVec[j].accYg;
learnFile << "," << actDataPoint->sensVec[j].accZg;
learnFile << "," << actDataPoint->sensVec[j].rotXg;
learnFile << "," << actDataPoint->sensVec[j].rotYg;
learnFile << "," << actDataPoint->sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << endl;
learnFile.close();
}
else
{
cout << "cannot open file to record to" << endl;
}
}
void DataFileHandler::writeDataFile(vector *gestureData, string fileName)
{
scaleAccelerometerData(gestureData);
//cout << "writeDataFile " << fileName << endl;
fstream learnFile;
learnFile.open(fileName.c_str(), ios::out|ios::app);
if(learnFile)
{
learnFile.clear();
for(int i=0; i < (int)gestureData->size(); i++)
{
for(uint j=0; j< gestureData->at(i).sensVec.size(); j++)
{
learnFile << gestureData->at(i).sensVec[j].accXg;
learnFile << "," << gestureData->at(i).sensVec[j].accYg;
learnFile << "," << gestureData->at(i).sensVec[j].accZg;
learnFile << "," << gestureData->at(i).sensVec[j].rotXg;
learnFile << "," << gestureData->at(i).sensVec[j].rotYg;
learnFile << "," << gestureData->at(i).sensVec[j].rotZg;
learnFile << ",;";
}
learnFile << endl;
}
learnFile.close();
}
}
}
5.classifierone.cpp file
#include "ClassifierOne.h"
#include "PresentOne.h"
#include "RecognitionWrapper.h"
#include "DataFileHandler.h"
using namespace std;
namespace HGR1 {
ClassifierOne::ClassifierOne(RecognitionWrapper *actWrapper)
{
scaling = true;
//scaling = false;
gestureList = new vector >;
gestureNameList = new vector;
scaledData = new vector;
if(actWrapper->dataFileHandler->getLearnedGesturesDTW(gestureList, gestureNameList))
{
cout << "Successfully loaded " << gestureList->size() << " gestures!" << endl;
//scaling
if(scaling)
{
for(uint l=0; l < gestureList->size(); l++)
{
double maxLength =0;
actWrapper->dataReduction->calcLengthDir(&(gestureList->at(l)));
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
if(gestureList->at(l).at(i).sensVec[j].accLength > maxLength)
{
maxLength = gestureList->at(l).at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
gestureList->at(l).at(i).sensVec[j].accXg = (gestureList->at(l).at(i).sensVec[j].accXg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accYg = (gestureList->at(l).at(i).sensVec[j].accYg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accZg = (gestureList->at(l).at(i).sensVec[j].accZg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].rotXg = gestureList->at(l).at(i).sensVec[j].rotXg;
gestureList->at(l).at(i).sensVec[j].rotYg = gestureList->at(l).at(i).sensVec[j].rotYg;
gestureList->at(l).at(i).sensVec[j].rotZg = gestureList->at(l).at(i).sensVec[j].rotZg;
gestureList->at(l).at(i).sensVec[j].accDir = gestureList->at(l).at(i).sensVec[j].accDir;
gestureList->at(l).at(i).sensVec[j].accLength = (gestureList->at(l).at(i).sensVec[j].accLength / maxLength)*32767;
}
}
}
}
}
}
}
ClassifierOne::~ClassifierOne() {
// TODO Auto-generated destructor stub
}
int ClassifierOne::run(RecognitionWrapper* actWrapper)
{
if(actWrapper->accData->timeSeries.size() == vectorLength)
{
//scaling
if(scaling)
{
double maxLength =0;
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
if(actWrapper->accData->timeSeries.at(i).sensVec[j].accLength > maxLength)
{
maxLength = actWrapper->accData->timeSeries.at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
dataPoint scaledDataPoint(actWrapper->accData->timeSeries.at(i).sensVec.size());
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
scaledDataPoint.sensVec[j].accXg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accXg / maxLength)*32767;
scaledDataPoint.sensVec[j].accYg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accYg / maxLength)*32767;
scaledDataPoint.sensVec[j].accZg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accZg / maxLength)*32767;
scaledDataPoint.sensVec[j].rotXg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotXg;
scaledDataPoint.sensVec[j].rotYg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotYg;
scaledDataPoint.sensVec[j].rotZg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotZg;
scaledDataPoint.sensVec[j].accDir = actWrapper->accData->timeSeries.at(i).sensVec[j].accDir;
scaledDataPoint.sensVec[j].accLength = (actWrapper->accData->timeSeries.at(i).sensVec[j].accLength / maxLength)*32767;
}
scaledData->push_back(scaledDataPoint);
}
}
}
int minDistGesture =0;
double distance =0;
double minDistance =100000000;
if(gestureList->size() > 0)
{
for(uint i=0; isize(); i++)
{
distance = 0;
for(uint j=0; j < gestureList->at(i).size(); j++)
{
if(scaling)
{
distance += gestureList->at(i)[j].euclid_distance(scaledData->at(j));
// distance += gestureList->at(i)[j].linear_distance(scaledData->at(j));
// distance += gestureList->at(i)[j].quant_distance(scaledData->at(j));
}
else
{
distance += gestureList->at(i)[j].euclid_distance(actWrapper->accData->timeSeries.at(j));
// distance += gestureList->at(i)[j].linear_distance(actWrapper->accData->timeSeries.at(j));
// distance += gestureList->at(i)[j].quant_distance(actWrapper->accData->timeSeries.at(j));
}
}
//cout << "distance = " << distance << endl;
if(distance < minDistance)
{
minDistance = distance;
minDistGesture = i;
}
}
}
//for Debug purposes:
//cout << "Minimal Distance is " << minDistance << " for gesture " << gestureNameList->at(minDistGesture) << " !" << endl;
if(minDistance < 140000) // this value is subject to change!
{
cout << "Easy most likely gesture: " << gestureNameList->at(minDistGesture) << " with " << minDistance << endl;
//winner takes all
}
return minDistGesture;
}
return 0;
}
void ClassifierOne::learnGesture(RecognitionWrapper *actWrapper, string learnName)
{
actWrapper->dataFileHandler->learnGesture(&(actWrapper->accData->timeSeries), learnName);
} }
6.classifierdtw.cpp file
#include "ClassifierDTW.h"
#include "vectordtw.h"
#include "DataFileHandler.h"
namespace HGR1 {
ClassifierDTW::ClassifierDTW(RecognitionWrapper* actWrapper)
{
scaling = true;
//scaling = false;
gestureList = new vector >;
gestureNameList = new vector;
scaledData = new vector;
if(actWrapper->dataFileHandler->getLearnedGesturesDTW(gestureList, gestureNameList))
{
cout << "Successfully loaded " << gestureList->size() << " gestures!" << endl;
//scaling
if(scaling)
{
for(uint l=0; l < gestureList->size(); l++)
{
double maxLength =0;
actWrapper->dataReduction->calcLengthDir(&(gestureList->at(l)));
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
if(gestureList->at(l).at(i).sensVec[j].accLength > maxLength)
{
maxLength = gestureList->at(l).at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < gestureList->at(l).size(); i++)
{
for(uint j=0; j < gestureList->at(l).at(i).sensVec.size(); j++)
{
gestureList->at(l).at(i).sensVec[j].accXg = (gestureList->at(l).at(i).sensVec[j].accXg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accYg = (gestureList->at(l).at(i).sensVec[j].accYg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].accZg = (gestureList->at(l).at(i).sensVec[j].accZg / maxLength)*32767;
gestureList->at(l).at(i).sensVec[j].rotXg = gestureList->at(l).at(i).sensVec[j].rotXg;
gestureList->at(l).at(i).sensVec[j].rotYg = gestureList->at(l).at(i).sensVec[j].rotYg;
gestureList->at(l).at(i).sensVec[j].rotZg = gestureList->at(l).at(i).sensVec[j].rotZg;
gestureList->at(l).at(i).sensVec[j].accDir = gestureList->at(l).at(i).sensVec[j].accDir;
gestureList->at(l).at(i).sensVec[j].accLength = (gestureList->at(l).at(i).sensVec[j].accLength / maxLength)*32767;
}
}
}
}
}
}
}
ClassifierDTW::~ClassifierDTW()
{
}
int ClassifierDTW::run(RecognitionWrapper* actWrapper)
{
if(actWrapper->accData->timeSeries.size() == vectorLength)
{
//scaling
if(scaling)
{
double maxLength =0;
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
if(actWrapper->accData->timeSeries.at(i).sensVec[j].accLength > maxLength)
{
maxLength = actWrapper->accData->timeSeries.at(i).sensVec[j].accLength;
}
}
}
scaledData->clear();
if(maxLength != 0)
{
for(uint i=0; i < actWrapper->accData->timeSeries.size(); i++)
{
dataPoint scaledDataPoint(actWrapper->accData->timeSeries.at(i).sensVec.size());
for(uint j=0; j < actWrapper->accData->timeSeries.at(i).sensVec.size(); j++)
{
scaledDataPoint.sensVec[j].accXg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accXg / maxLength)*32767;
scaledDataPoint.sensVec[j].accYg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accYg / maxLength)*32767;
scaledDataPoint.sensVec[j].accZg = (actWrapper->accData->timeSeries.at(i).sensVec[j].accZg / maxLength)*32767;
scaledDataPoint.sensVec[j].rotXg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotXg;
scaledDataPoint.sensVec[j].rotYg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotYg;
scaledDataPoint.sensVec[j].rotZg = actWrapper->accData->timeSeries.at(i).sensVec[j].rotZg;
scaledDataPoint.sensVec[j].accDir = actWrapper->accData->timeSeries.at(i).sensVec[j].accDir;
scaledDataPoint.sensVec[j].accLength = (actWrapper->accData->timeSeries.at(i).sensVec[j].accLength / maxLength)*32767;
}
scaledData->push_back(scaledDataPoint);
}
}
}
//actWrapper->actResult.resultDTW = NONEDTW;
VectorDTW dtw1(actWrapper->accData->timeSeries.size(), actWrapper->accData->timeSeries.size(), 6);
int minDistGesture =0;
double distance =0;
double minDistance =100000000;
if(gestureList->size() > 0)
{
for(uint i=0; isize(); i++)
{
if(scaling)
{
distance = dtw1.calcDTWDistanceSensor(*scaledData, gestureList->at(i));
}
else
{
distance = dtw1.calcDTWDistanceSensor(actWrapper->accData->timeSeries, gestureList->at(i));
}
//cout << "distance = " << distance << endl;
if(distance < minDistance)
{
minDistance = distance;
minDistGesture = i;
}
}
}
//for Debug purposes:
//cout << "Minimal Distance is " << minDistance << " for gesture " << gestureNameList->at(minDistGesture) << " !" << endl;
if(minDistance < 140000) // this value is subject to change!
{
cout << "DTW most likely gesture: " << gestureNameList->at(minDistGesture) << " with " << minDistance << endl;
//winner takes all
}
return minDistGesture;
}
return 0;
}
void ClassifierDTW::learnGesture(RecognitionWrapper *actWrapper, string learnName)
{
actWrapper->dataFileHandler->learnGesture(&(actWrapper->accData->timeSeries), learnName);
//cout << "Learned gesture " << learnName << endl;
}
}