FHWS/Indoor
Archived
4
0
Fork 0
Code Issues 19 Pull Requests Releases 1 Wiki Activity

rebase activity rec

Browse Source
This commit is contained in:
toni
2017-10-24 12:44:16 +02:00
parent 3e31f6da53
commit 0151a4f6e4
2 changed files with 8 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
sensors/pressure/ActivityButterPressure.h
View File

@@ -1,136 +0,0 @@
#ifndef ACTIVITYBUTTERPRESSURE_H
#define ACTIVITYBUTTERPRESSURE_H
#include "../../data/Timestamp.h"
#include "../../math/filter/Butterworth.h"
#include "../../math/FixedFrequencyInterpolator.h"
#include "../../math/MovingAVG.h"
#include "BarometerData.h"
/**
* receives pressure measurements, interpolates them to a ficex frequency, lowpass filtering
* activity recognition based on a small window given by matlabs diff(window)
*/
class ActivityButterPressure {
public:
enum Activity {DOWN, STAY, UP};
struct History {
Timestamp ts;
BarometerData data;
History(const Timestamp ts, const BarometerData data) : ts(ts), data(data) {;}
};
private:
std::vector<History> output;
Activity currentActivity;
MovingAVG<float> mvAvg = MovingAVG<float>(20);
/** change this values for much success
*
* Nexus 6:
* butter = Filter::ButterworthLP<float>(10,0.1f,2);
* threshold = 0.025;
* diffSize = 20;
* FixedFrequencyInterpolator<float> ffi = FixedFrequencyInterpolator<float>(Timestamp::fromMS(100));
*/
const bool additionalLowpassFilter = false;
const unsigned long diffSize = 20; //the number values used for finding the activity.
const float threshold = 0.025f; // if diffSize is getting smaller, treshold needs to be adjusted in the same direction!
Filter::ButterworthLP<float> butter = Filter::ButterworthLP<float>(10,0.05f,2);
Filter::ButterworthLP<float> butter2 = Filter::ButterworthLP<float>(10,0.05f,2);
FixedFrequencyInterpolator<float> ffi = FixedFrequencyInterpolator<float>(Timestamp::fromMS(100));
public:
/** ctor */
ActivityButterPressure() : currentActivity(STAY){
;
}
/** add new sensor readings that were received at the given timestamp */
Activity add(const Timestamp& ts, const BarometerData& baro) {
//init
static bool firstCall = false;
if(!firstCall){
butter.stepInitialization(baro.hPa);
firstCall = true;
butter2.stepInitialization(0);
return STAY;
}
bool newInterpolatedValues = false;
//interpolate & butter
auto callback = [&] (const Timestamp ts, const float val) {
float interpValue = val;
//butter
float butterValue = butter.process(interpValue);
output.push_back(History(ts, BarometerData(butterValue)));
newInterpolatedValues = true;
};
ffi.add(ts, baro.hPa, callback);
if(newInterpolatedValues == true){
//getActivity
if(output.size() > diffSize){
//diff
std::vector<float> diff;
for(unsigned long i = output.size() - diffSize; i < output.size() - 1; ++i){
float diffVal = output[i+1].data.hPa - output[i].data.hPa;
diff.push_back(diffVal);
}
float sum = 0;
for(float val : diff){
sum += val;
}
float actValue = 0;
if(additionalLowpassFilter == true){
//additional butter/moving average for the results
//mvAvg.add(sum);
//actValue = mvAvg.get();
actValue = butter2.process(sum);
}else{
actValue = sum;
}
if(actValue > threshold){
currentActivity = DOWN;
}
else if (actValue < -threshold){
currentActivity = UP;
}
else{
currentActivity = STAY;
}
}
}
return currentActivity;
}
/** get the current Activity */
Activity getCurrentActivity() {
return currentActivity;
}
};
#endif // ACTIVITYBUTTERPRESSURE_H

187
sensors/pressure/ActivityButterPressurePercent.h
View File

@@ -1,187 +0,0 @@
#ifndef ACTIVITYBUTTERPRESSUREPERCENT_H
#define ACTIVITYBUTTERPRESSUREPERCENT_H
#include "../../data/Timestamp.h"
#include "../../math/filter/Butterworth.h"
#include "../../math/FixedFrequencyInterpolator.h"
#include "../../math/distribution/Normal.h"
#include <KLib/Assertions.h>
#include <vector>
#include "BarometerData.h"
/**
* receives pressure measurements, interpolates them to a ficex frequency, lowpass filtering
* activity recognition based on a small window given by matlabs diff(window)
*
* todo: if an elevator is detected, first we have a short time the stairs are more prober.
*/
class ActivityButterPressurePercent {
public:
struct ActivityProbabilities{
float elevatorDown;
float stairsDown;
float stay;
float stairsUp;
float elevatorUp;
ActivityProbabilities(float elevatorDown, float stairsDown,
float stay, float stairsUp, float elevatorUp) :
elevatorDown(elevatorDown), stairsDown(stairsDown),
stay(stay), stairsUp(stairsUp), elevatorUp(elevatorUp) {;}
ActivityProbabilities() :
elevatorDown(0.01f), stairsDown(0.01f),
stay(0.96f), stairsUp(0.01f), elevatorUp(0.01f) {;}
};
struct History {
Timestamp ts;
BarometerData data;
History(const Timestamp ts, const BarometerData data) : ts(ts), data(data) {;}
};
private:
std::vector<History> output;
bool initialize;
ActivityProbabilities currentActivity;
/** change this values for much success */
const unsigned long diffSize = 20; //the number values used for finding the activity.
Filter::ButterworthLP<float> butter = Filter::ButterworthLP<float>(10,0.05f,2);
FixedFrequencyInterpolator<float> ffi = FixedFrequencyInterpolator<float>(Timestamp::fromMS(100));
const float variance = 0.02f;
const float muStairs = 0.04f;
const float muStay = 0.00f;
const float muEleveator = 0.08f;
std::vector<float> densities = std::vector<float>(5, 1);
std::vector<float> densitiesOld = std::vector<float>(5, 1);
public:
/** ctor */
ActivityButterPressurePercent() : currentActivity(ActivityProbabilities(0.01f, 0.01f, 0.96f, 0.01f, 0.01f)){
initialize = true;
}
/** add new sensor readings that were received at the given timestamp */
ActivityProbabilities add(const Timestamp& ts, const BarometerData& baro) {
//init
if(initialize){
butter.stepInitialization(baro.hPa);
initialize = false;
return currentActivity;
}
bool newInterpolatedValues = false;
//interpolate & butter
auto callback = [&] (const Timestamp ts, const float val) {
float interpValue = val;
//butter
float butterValue = butter.process(interpValue);
output.push_back(History(ts, BarometerData(butterValue)));
newInterpolatedValues = true;
};
ffi.add(ts, baro.hPa, callback);
if(newInterpolatedValues == true){
//getActivity
if(output.size() > diffSize){
//diff
std::vector<float> diff;
for(unsigned long i = output.size() - diffSize; i < output.size() - 1; ++i){
float diffVal = output[i+1].data.hPa - output[i].data.hPa;
diff.push_back(diffVal);
}
float sum = 0;
for(float val : diff){
sum += val;
}
float actValue = sum;
//calculate the probabilites of walking down/up etc...
densitiesOld = densities;
//in one building there is an ultra fast elevator, therefore we need to clip the activity value...
if(actValue > muEleveator){
actValue = muEleveator;
}
if(actValue < -muEleveator){
actValue = -muEleveator;
}
float densityElevatorDown = Distribution::Normal<float>::getProbability(muEleveator, variance, actValue);
float densityStairsDown = Distribution::Normal<float>::getProbability(muStairs, variance, actValue);
float densityStay = Distribution::Normal<float>::getProbability(muStay, variance, actValue);
float densityStairsUp = Distribution::Normal<float>::getProbability(-muStairs, variance, actValue);
float densityElevatorUp = Distribution::Normal<float>::getProbability(-muEleveator, variance, actValue);
_assertTrue( (densityElevatorDown == densityElevatorDown), "the probability of densityElevatorDown is null!");
_assertTrue( (densityStairsDown == densityStairsDown), "the probability of densityStairsDown is null!");
_assertTrue( (densityStay == densityStay), "the probability of densityStay is null!");
_assertTrue( (densityStairsUp == densityStairsUp), "the probability of densityStairsUp is null!");
_assertTrue( (densityElevatorUp == densityElevatorUp), "the probability of densityElevatorUp is null!");
_assertTrue( (densityElevatorDown != 0.0f), "the probability of densityElevatorDown is null!");
_assertTrue( (densityStairsDown != 0.0f), "the probability of densityStairsDown is null!");
_assertTrue( (densityStay != 0.0f), "the probability of densityStay is null!");
_assertTrue( (densityStairsUp != 0.0f), "the probability of densityStairsUp is null!");
_assertTrue( (densityElevatorUp != 0.0f), "the probability of densityElevatorUp is null!");
//wenn aufzug / treppe der größte wert, werden für x timestamps auf die jeweilige katerogie multipliziert.
densities[0] = densityElevatorDown;
densities[1] = densityStairsDown;
densities[2] = densityStay;
densities[3] = densityStairsUp;
densities[4] = densityElevatorUp;
//normalize
float densitySum = densities[0] + densities[1] + densities[2] + densities[3] + densities[4];
for(unsigned long i = 0; i < densities.size(); ++i){
densities[i] /= densitySum;
//values cant be zero!
densities[i] = (densities[i] > 0.0f ? densities[i] : 0.01f);
}
currentActivity = ActivityProbabilities(densities[0], densities[1], densities[2], densities[3], densities[4]);
}
}
//retruns for every call, indepedent of callback.
return currentActivity;
}
/** get the current Activity */
ActivityProbabilities getCurrentActivity() {
return currentActivity;
}
};
#endif // ACTIVITYBUTTERPRESSUREPERCENT_H