added gitignore file to repo

.gitignore

@@ -0,0 +1,198 @@
+## Compiled Object files
+*.slo
+*.lo
+*.o
+
+## Compiled Dynamic libraries
+*.so
+*.dylib
+
+## Compiled Static libraries
+*.lai
+*.la
+*.a
+
+# when using qt-creator
+code/CMakeLists.txt.user
+
+## build folder
+code-build/
+measurements/
+
+## Core latex/pdflatex auxiliary files:
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+
+## Intermediate documents:
+*.dvi
+*-converted-to.*
+# these rules might exclude image files for figures etc.
+# *.ps
+# *.eps
+# *.pdf
+
+## Bibliography auxiliary files (bibtex/biblatex/biber):
+*.bbl
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.brf
+*.run.xml
+
+## Build tool auxiliary files:
+*.fdb_latexmk
+*.synctex
+*.synctex.gz
+*.synctex.gz(busy)
+*.pdfsync
+
+## Auxiliary and intermediate files from other packages:
+# algorithms
+*.alg
+*.loa
+
+# achemso
+acs-*.bib
+
+# amsthm
+*.thm
+
+# beamer
+*.nav
+*.snm
+*.vrb
+
+# cprotect
+*.cpt
+
+# fixme
+*.lox
+
+#(r)(e)ledmac/(r)(e)ledpar
+*.end
+*.?end
+*.[1-9]
+*.[1-9][0-9]
+*.[1-9][0-9][0-9]
+*.[1-9]R
+*.[1-9][0-9]R
+*.[1-9][0-9][0-9]R
+*.eledsec[1-9]
+*.eledsec[1-9]R
+*.eledsec[1-9][0-9]
+*.eledsec[1-9][0-9]R
+*.eledsec[1-9][0-9][0-9]
+*.eledsec[1-9][0-9][0-9]R
+
+# glossaries
+*.acn
+*.acr
+*.glg
+*.glo
+*.gls
+*.glsdefs
+
+# gnuplottex
+*-gnuplottex-*
+
+# hyperref
+*.brf
+
+# knitr
+*-concordance.tex
+# TODO Comment the next line if you want to keep your tikz graphics files
+*.tikz
+*-tikzDictionary
+
+# listings
+*.lol
+
+# makeidx
+*.idx
+*.ilg
+*.ind
+*.ist
+
+# minitoc
+*.maf
+*.mlf
+*.mlt
+*.mtc
+*.mtc[0-9]
+*.mtc[1-9][0-9]
+
+# minted
+_minted*
+*.pyg
+
+# morewrites
+*.mw
+
+# mylatexformat
+*.fmt
+
+# nomencl
+*.nlo
+
+# sagetex
+*.sagetex.sage
+*.sagetex.py
+*.sagetex.scmd
+
+# sympy
+*.sout
+*.sympy
+sympy-plots-for-*.tex/
+
+# pdfcomment
+*.upa
+*.upb
+
+# pythontex
+*.pytxcode
+pythontex-files-*/
+
+# TikZ & PGF
+*.dpth
+*.md5
+*.auxlock
+
+# todonotes
+*.tdo
+
+# xindy
+*.xdy
+
+# xypic precompiled matrices
+*.xyc
+
+# endfloat
+*.ttt
+*.fff
+
+# Latexian
+TSWLatexianTemp*
+
+## Editors:
+# WinEdt
+*.bak
+*.sav
+
+# Texpad
+.texpadtmp
+
+# Kile
+*.backup
+
+# KBibTeX
+*~[0-9]*

code/Settings.h

@@ -19,6 +19,10 @@ namespace MiscSettings {
 
 	const int numParticles = 7500;
 
+    const int lag = 5;
+
+    const int fixedLagGap = 1;
+
 }
 
 

code/Vis.h

@@ -2,6 +2,7 @@
 #define VIS_H
 
 #include <KLib/misc/gnuplot/Gnuplot.h>
+#include <KLib/misc/gnuplot/GnuplotSize.h>
 #include <KLib/misc/gnuplot/GnuplotSplot.h>
 #include <KLib/misc/gnuplot/GnuplotSplotElementLines.h>
 #include <KLib/misc/gnuplot/GnuplotSplotElementPoints.h>
@@ -28,8 +29,10 @@ public:
 	K::GnuplotSplotElementLines particleDir;
 
 	K::GnuplotSplotElementLines estPath;
+    K::GnuplotSplotElementLines smoothPath;
 	K::GnuplotSplotElementLines groundTruth;
 
+
 public:
 
 	Vis() {
@@ -52,6 +55,8 @@ public:
 		particleDir.setColorHex("#444444");
 
 		estPath.setLineWidth(2);
+        smoothPath.setLineWidth(2);
+        smoothPath.setColorHex("#59C1DA");
 
 		// attach all layers
 		splot.add(&floors);
@@ -61,6 +66,7 @@ public:
 		splot.add(&particles);
 		splot.add(&groundTruth);
 		splot.add(&estPath);
+        splot.add(&smoothPath);
 
 	}
 
@@ -124,11 +130,27 @@ public:
 		}
 	}
 
+    void addSmoothPath(std::vector<Point3>& smt) {
+        smoothPath.clear();;
+        for (const Point3& p : smt) {
+            K::GnuplotPoint3 gp(p.x, p.y, p.z);
+            smoothPath.add(gp);
+        }
+    }
+
 	void setTimestamp(uint64_t ts) {
 		static uint64_t firstTs = ts;
 		gp << "set label 1 \"" << ((ts-firstTs)/1000.0f) << "\" at screen 0.02,0.98\n";
 	}
 
+    void setFilteringMedian(double median){
+        gp << "set label 2 \"" << median << "\" at screen 0.02,0.90\n";
+    }
+
+    void setSmoothingMedian(double median){
+        gp << "set label 3 \"" << median << "\" at screen 0.02,0.85\n";
+    }
+
 	void removeGrid() {
 		gridNodes.clear();;
 	}
@@ -138,20 +160,26 @@ public:
 		particleDir.clear();
 	}
 
-	void addObject(const int idx, const Point3& p) {
+    void addObject(const int idx, const Point3& p, const std::string& hex) {
 		gp << "set object " << idx << " polygon ";
 		gp << "from " << p.x << "," << p.y << "," << p.z;
 		gp << "  to " << p.x << "," << p.y << "," << p.z + 200;
 		gp << "  to " << p.x << "," << p.y << "," << p.z;				// close
 		gp << " lw 2 ";
+        gp << "fc rgb '" + hex + "'";
 		gp << "\n";
 	}
 
 	void setEstAndShould(const Point3& est, const Point3& should) {
-		addObject(2,est);
+        addObject(2,est, "#000000");
-		addObject(3,should);
+        addObject(3,should, "#000000");
 	}
 
+    void setEstAndShould2(const Point3& est, const Point3& should) {
+        addObject(4,est, "#59C1DA");
+        addObject(5,should, "#59C1DA");
+    }
+
 	template <typename T> void addState(const GridWalkState<T>& n) {
 		Point2 dir = Angle::getPointer(n.heading.getRAD());
 		K::GnuplotPoint3 p1(n.node->x_cm, n.node->y_cm, n.node->z_cm);

code/eval/Eval1.h

@@ -215,7 +215,7 @@ public:
 
 		runName = "path4_nexus_path";
 
-		BarometerEvaluation::barometerSigma = 0.05;
+        BarometerEvaluation::barometerSigma = 0.05;
 		sr = new SensorReader("./measurements/path4/nexus/1454695040555.csv"); // forward
 		srt = new SensorReaderTurn("./measurements/path4/nexus/Turns.txt");
 		srs = new SensorReaderStep("./measurements/path4/nexus/Steps2.txt");

code/eval/FixedLagEvalBase.h

@@ -0,0 +1,395 @@
+#ifndef FIXEDLAGEVALBASE_H
+#define FIXEDLAGEVALBASE_H
+
+#include "../Settings.h"
+#include "../Helper.h"
+#include "../Vis.h"
+
+#include <KLib/math/filter/particles/ParticleFilter.h>
+#include <KLib/math/filter/particles/ParticleFilterHistory.h>
+#include <KLib/math/filter/smoothing/BackwardSimulation.h>
+#include <KLib/math/filter/smoothing/sampling/ParticleTrajectorieSampler.h>
+#include <KLib/math/filter/smoothing/sampling/CumulativeSampler.h>
+#include <KLib/math/statistics/Statistics.h>
+
+#include "GroundTruthWay.h"
+
+#include "../particles/MyState.h"
+#include "../particles/MyObservation.h"
+#include "../particles/MyEvaluation.h"
+#include "../particles/MyTransition.h"
+#include "../particles/MyInitializer.h"
+#include "../particles/smoothing/MySmoothingTransition.h"
+#include "../particles/smoothing/MySmoothingTransitionSimple.h"
+#include "../particles/smoothing/MySmoothingTransitionExperimental.h"
+
+#include "../reader/SensorReader.h"
+#include "../reader/SensorReaderStep.h"
+#include "../reader/SensorReaderTurn.h"
+
+#include "../lukas/TurnObservation.h"
+#include "../lukas/StepObservation.h"
+
+#include "../toni/BarometerSensorReader.h"
+
+#include "../frank/WiFiSensorReader.h"
+#include "../frank/BeaconSensorReader.h"
+#include "../frank/OrientationSensorReader.h"
+
+class FixedLagEvalBase {
+
+protected:
+
+	Grid<MyGridNode> grid;
+	Helper::FHWSFloors floors;
+	Vis vis;
+
+    K::ParticleFilterHistory<MyState, MyControl, MyObservation>* pf;
+    K::BackwardFilter<MyState>* bf;
+
+	SensorReader* sr;
+	SensorReaderTurn* srt;
+    SensorReaderStep* srs;
+
+
+	std::string runName;
+
+	GroundTruthWay gtw;
+
+	// OLD
+	//std::vector<int> way0 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 1, 0};
+	//std::vector<int> way1 = {29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 13, 14, 15, 16, 17, 18, 19, 2, 1, 0};
+	//std::vector<int> way2 = {29, 28, 27, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 19, 18, 17, 16, 15, 14, 13, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29};
+
+	// NEW
+	std::vector<int> path1 = {29, 28,27,26,255,25,24,23,22,21,20};
+	std::vector<int> path1dbl = {29, 29, 28,27,26,255,25,24,23,22,21,20};
+	std::vector<int> path2 = {19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 23, 7, 6};
+	std::vector<int> path2dbl = {19, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 23, 7, 6};
+	std::vector<int> path3 = {5, 27, 26, 255, 25, 4, 3, 2, 215, 1, 0, 30, 31};
+	std::vector<int> path3dbl = {5, 5, 27, 26, 255, 25, 4, 3, 2, 215, 1, 0, 30, 31};
+	std::vector<int> path4 = {29, 28, 27, 32, 33, 34, 35, 36, 10, 9, 8, 22, 37, 38, 39, 40, 41, 42, 43, 44};
+	std::vector<int> path4dbl = {29, 29, 28, 27, 32, 33, 34, 35, 36, 10, 9, 8, 22, 37, 38, 39, 40, 41, 42, 43, 44};	// duplicate 1st waypoint!
+
+    float stepSize = 0.71;
+
+public:
+
+    FixedLagEvalBase() : grid(MiscSettings::gridSize_cm), floors(Helper::getFloors(grid)) {
+
+		// build the grid
+		Helper::buildTheGrid(grid, floors);
+
+		// setup the visualisation
+		vis.addFloor(floors.f0, floors.h0);
+		vis.addFloor(floors.f1, floors.h1);
+		vis.addFloor(floors.f2, floors.h2);
+		vis.addFloor(floors.f3, floors.h3);
+
+		vis.floors.setColorHex("#666666");
+		vis.groundTruth.setCustomAttr("dashtype 3");
+		vis.groundTruth.setColorHex("#009900");
+        vis.gp << "unset cbrange\n";
+
+
+	}
+
+	static GridPoint conv(const Point3& p) {
+		return GridPoint(p.x, p.y, p.z);
+	}
+
+	GroundTruthWay getGroundTruthWay(SensorReader& sr, const std::unordered_map<int, Point3>& waypoints, std::vector<int> ids) {
+
+		// construct the ground-truth-path by using all contained waypoint ids
+		std::vector<Point3> path;
+		for (int id : ids) {
+			auto it = waypoints.find(id);
+			if(it == waypoints.end()) {throw "not found";}
+			path.push_back(it->second);
+		}
+
+		// new created the timed path
+		GroundTruthWay gtw;
+		int i = 0;
+		while (sr.hasNext()) {
+			const SensorEntry se = sr.getNext();
+			if (se.data.empty()) {continue;}		// why necessary??
+			if (se.idx == 99) {
+				gtw.add(se.ts, path[i]);
+				++i;
+			}
+		}
+
+		// ensure the sensor-data contained usable timestamps for the ground-truth mapping
+		assert(i>0);
+
+		sr.rewind();
+		return gtw;
+
+	}
+
+	void run() {
+
+        // sensor numbers
+        const int s_wifi = 8; const int s_beacons = 9; const int s_barometer = 5; const int s_orientation = 6;
+        //const int s_linearAcceleration = 2;
+
+        std::list<TurnObservation> turn_observations;
+        std::list<StepObservation> step_observations;
+
+        //Create an BarometerSensorReader
+        BarometerSensorReader baroSensorReader;
+
+
+        //Read all turn Observations
+        while(srt->hasNext()) {
+
+            SensorEntryTurn set = srt->getNext();
+            TurnObservation to;
+
+            to.ts = set.ts;
+            to.delta_heading = set.delta_heading;
+            to.delta_motion = set.delta_motion;
+
+            turn_observations.push_back(to);
+        }
+
+
+        //Step Observations
+        while(srs->hasNext()) {
+
+            SensorEntryStep ses = srs->getNext();
+            StepObservation so;
+
+            so.ts = ses.ts;
+
+            step_observations.push_back(so);
+        }
+
+
+
+        // the to-be-evaluated observation
+        MyObservation obs;
+        obs.step = new StepObservation(); obs.step->steps = 0;
+        obs.turn = new TurnObservation(); obs.turn->delta_heading = 0; obs.turn->delta_motion = 0;
+
+        // control data
+        MyControl ctrl;
+
+        //History of all estimated particles. Used for smoothing
+        std::vector<std::vector<K::Particle<MyState>>> pfHistory;
+        std::vector<Point3> smoothedEst;
+        std::vector<uint64_t> tsHistory;
+
+        std::vector<Point3> pathEst;
+
+        uint64_t lastTransitionTS = 0;
+        int64_t start_time = -1;
+
+        K::Statistics<double> statsFiltering;
+        K::Statistics<double> statsSmoothing;
+        int cnt = 0;
+
+        //stats file
+        std::ofstream statsout("/tmp/unsmoothed_" + runName + ".stats");
+
+        // process each single sensor reading
+        while(sr->hasNext()) {
+
+            // get the next sensor reading from the CSV
+            const SensorEntry se = sr->getNext();
+
+            //start_time needed for time calculation of steps and turns
+            obs.latestSensorDataTS = se.ts;
+            if (start_time == -1) {start_time = se.ts;}
+            int64_t current_time = se.ts - start_time;
+
+            switch(se.idx) {
+
+                case s_wifi: {
+                    obs.wifi = WiFiSensorReader::readWifi(se);
+                    break;
+                }
+
+                case s_beacons: {
+                    BeaconObservationEntry boe = BeaconSensorReader::getBeacon(se);
+                    if (!boe.mac.empty()) {
+                        obs.beacons.entries.push_back(boe);
+                    }			// add the observed beacon
+                    obs.beacons.removeOld(obs.latestSensorDataTS);
+                    break;
+                }
+
+                case s_barometer: {
+                    obs.barometer = baroSensorReader.readBarometer(se);
+                    break;
+                }
+
+//					case s_linearAcceleration:{
+//						baroSensorReader.readVerticalAcceleration(se);
+//						break;
+//					}
+
+                case s_orientation: {
+                    obs.orientation = OrientationSensorReader::read(se);
+                    break;
+                }
+
+            }
+
+            // process all occurred turns
+            while (!step_observations.empty() && current_time > step_observations.front().ts) {
+                const StepObservation _so = step_observations.front(); step_observations.pop_front(); (void) _so;
+                obs.step->steps++;
+                ctrl.walked_m = obs.step->steps * stepSize;
+            }
+
+            // process all occurred steps
+            while (!turn_observations.empty() && current_time > turn_observations.front().ts) {
+                const TurnObservation _to = turn_observations.front(); turn_observations.pop_front();
+                obs.turn->delta_heading += _to.delta_heading;
+                obs.turn->delta_motion += _to.delta_motion;
+                ctrl.headingChange_rad = Angle::degToRad(obs.turn->delta_heading);
+
+            }
+
+
+            // time for a transition?
+            if (se.ts - lastTransitionTS > MiscSettings::timeSteps) {
+
+                lastTransitionTS = se.ts;
+
+                // timed updates
+                ((MyTransition*)pf->getTransition())->setCurrentTime(lastTransitionTS);
+
+
+                // update the particle filter (transition + eval), estimate a new current position and add it to the estimated path
+                const MyState est = pf->update(&ctrl, obs);
+                const Point3 curEst = est.pCur;
+
+                // error calculation. compare ground-truth to estimation
+                const int offset = 0;
+                const Point3 curGT = gtw.getPosAtTime(se.ts - offset);
+                const Point3 diff = curEst - curGT;
+
+
+                pathEst.push_back(curEst);
+                const float err = diff.length();
+
+                // skip the first 24 scans due to uniform distribution start
+                if (++cnt > 24) {
+                    statsFiltering.add(err);
+                    std::cout << "Filtering: " << statsFiltering.asString() << std::endl;
+                }
+
+                if(cnt > 19){
+                    //save the current estimation for later smoothing.
+                    pfHistory.push_back(pf->getNonResamplingParticles());
+                    tsHistory.push_back(se.ts);
+                }
+
+
+                //fixed-lag smoothing
+                MyState estBF;
+                if(pfHistory.size() >= MiscSettings::lag){
+
+                    bf->reset();
+
+                    //use every n-th (std = 1) particle set of the history within a given lag (std = 5)
+                    for(int i = 0; i < MiscSettings::lag; i += MiscSettings::fixedLagGap){
+
+                        ((MySmoothingTransitionSimple*)bf->getTransition())->setCurrentTime(tsHistory[(tsHistory.size() - 1) - i]);
+                        estBF = bf->update(pfHistory[(pfHistory.size() - 1) - i]);
+
+                    }
+
+                    //use and visualize the smoothed particle set
+                    const Point3 curSmoothedEst = estBF.pCur;
+
+                    smoothedEst.push_back(curSmoothedEst);
+
+                    // error calculation. compare ground-truth to estimation
+                    const Point3 curGTSmoothed = gtw.getPosAtTime(se.ts - (MiscSettings::lag * MiscSettings::timeSteps));
+                    const Point3 diffSmoothed = curSmoothedEst - curGTSmoothed;
+
+                    const float errSmoothed = diffSmoothed.length();
+                    statsSmoothing.add(errSmoothed);
+                    std::cout << "Smoothing: " << statsSmoothing.asString() << std::endl;
+
+                    //plot
+                    vis.clearStates();
+                    for (int j = 0; j < (int) bf->getbackwardParticles().back().size(); j+=15) {
+                        const K::Particle<MyState>& p = bf->getbackwardParticles().back()[j];
+                        vis.addState(p.state.walkState);
+                    }
+                    //vis.setTimestamp(se.ts);
+                    vis.setFilteringMedian(statsFiltering.getMedian());
+                    vis.setSmoothingMedian(statsSmoothing.getMedian());
+                    vis.addGroundTruth(gtw);
+                    vis.addEstPath(pathEst);
+                    vis.addSmoothPath(smoothedEst);
+                    vis.setEstAndShould(curEst, curGT);
+                    vis.setEstAndShould2(curSmoothedEst, curGTSmoothed);
+
+                    if (obs.barometer != nullptr) {
+                        vis.gp << "set label 112 'baro: " << obs.barometer->hpa << "' at screen 0.1,0.2\n";
+                    }
+                    vis.gp << "set label 111 '" <<ctrl.walked_m << ":" << ctrl.headingChange_rad << "' at screen 0.1,0.1\n";
+
+                    //vis.gp << "set label 111 '" <<ctrl.walked_m << ":" << obs.orientation.values[0] << "' at screen 0.1,0.1\n";
+
+                    Point2 p1(0.1, 0.1);
+                    Point2 p2 = p1 + Angle::getPointer(ctrl.headingChange_rad) * 0.05;
+                    //Point2 p2 = p1 + Angle::getPointer(obs.orientation.values[0]) * 0.05;
+                    vis.gp << "set arrow 999 from screen " << p1.x<<","<<p1.y << " to screen " << p2.x<<","<<p2.y<<"\n";
+
+                    vis.show();
+
+                    // prevent gnuplot errors
+                    usleep(1000*33);
+                }
+            }
+
+        }
+        statsout.close();
+
+        // plot
+        //vis.clearStates();
+        vis.gp.setTerminal("png", K::GnuplotSize(1280 * 2.54, 720 * 2.54) );
+        vis.gp.setOutput("/tmp/" + runName + ".png");
+        vis.gp << "set view 60," << 40 << "\n"; //For fixed position
+
+        for (int j = 0; j < (int) bf->getbackwardParticles().back().size(); j+=15) {
+            const K::Particle<MyState>& p = bf->getbackwardParticles().back()[j];
+            vis.addState(p.state.walkState);
+        }
+        //vis.setTimestamp(se.ts);
+        vis.setFilteringMedian(statsFiltering.getMedian());
+        vis.setSmoothingMedian(statsSmoothing.getMedian());
+        vis.addGroundTruth(gtw);
+        vis.addEstPath(pathEst);
+        vis.addSmoothPath(smoothedEst);
+        //vis.setEstAndShould(curEst, curGT);
+        //vis.setEstAndShould2(curSmoothedEst, curGTSmoothed);
+
+        if (obs.barometer != nullptr) {
+            vis.gp << "set label 112 'baro: " << obs.barometer->hpa << "' at screen 0.1,0.2\n";
+        }
+        vis.gp << "set label 111 '" <<ctrl.walked_m << ":" << ctrl.headingChange_rad << "' at screen 0.1,0.1\n";
+
+        //vis.gp << "set label 111 '" <<ctrl.walked_m << ":" << obs.orientation.values[0] << "' at screen 0.1,0.1\n";
+
+        Point2 p1(0.1, 0.1);
+        Point2 p2 = p1 + Angle::getPointer(ctrl.headingChange_rad) * 0.05;
+        //Point2 p2 = p1 + Angle::getPointer(obs.orientation.values[0]) * 0.05;
+        vis.gp << "set arrow 999 from screen " << p1.x<<","<<p1.y << " to screen " << p2.x<<","<<p2.y<<"\n";
+
+        vis.show();
+
+        // prevent gnuplot errors
+        usleep(1000*33);
+    }
+
+};
+
+#endif // EVALBASE_H

code/eval/PaperVisImportance.h

@@ -115,8 +115,8 @@ public:
 		// start and end
 		//const MyGridNode& gnStart = grid.getNodeFor(GridPoint(1500, 300, 0));
 		//const MyGridNode& gnEnd = grid.getNodeFor(GridPoint(900, 4600, 0));
-		const MyGridNode& gnStart = grid.getNodeFor(GridPoint(300, 300, 0));
+        const MyGridNode& gnStart = grid.getNodeFor(GridPoint(300, 300, 0));
-		const MyGridNode& gnEnd = grid.getNodeFor(GridPoint(4700, 1300, 0));
+        const MyGridNode& gnEnd = grid.getNodeFor(GridPoint(4700, 1300, 0));
 
 		// build all shortest path to reach th target
 		Dijkstra<MyGridNode> dijkstra;
@@ -124,7 +124,7 @@ public:
 		DijkstraMapperNormal accNormal(grid);
 
 		// path without importance
-		dijkstra.build(gnStart, gnStart, accNormal);
+        dijkstra.build(&gnStart, accNormal);
 		DijkstraPath<MyGridNode> pathNormal(dijkstra.getNode(gnEnd), dijkstra.getNode(gnStart));
 
 		// stamp importance information onto the grid-nodes
@@ -132,7 +132,7 @@ public:
 		gridImp.addImportance(grid, h0.cm());
 
 		// path WITH importance
-		dijkstra.build(gnStart, gnStart, accImp);
+        dijkstra.build(&gnStart, accImp);
 		DijkstraPath<MyGridNode> pathImp(dijkstra.getNode(gnEnd), dijkstra.getNode(gnStart));
 
 		// build plot
@@ -240,7 +240,7 @@ public:
 
 		// path WITH importance
 		DijkstraMapper accImp(grid);
-		dijkstra.build(gnStart, gnStart, accImp);
+        dijkstra.build(&gnStart, accImp);
 		DijkstraPath<MyGridNode> pathImp(dijkstra.getNode(gnEnd), dijkstra.getNode(gnStart));
 
 		// stamp distance information onto the grid

code/eval/SmoothingEval1.h

@@ -2,6 +2,7 @@
 #define SMOOTHINGEVAL1_H
 
 #include "SmoothingEvalBase.h"
+#include "FixedLagEvalBase.h"
 #include "../DijkstraMapper.h"
 #include <Indoor/grid/walk/GridWalkRandomHeadingUpdate.h>
 #include <Indoor/grid/walk/GridWalkRandomHeadingUpdateAdv.h>
@@ -20,7 +21,7 @@
 #include <KLib/math/filter/particles/estimation/ParticleFilterEstimationRegionalWeightedAverage.h>
 #include <KLib/math/filter/particles/estimation/ParticleFilterEstimationOrderedWeightedAverage.h>
 
-class SmoothingEval1 : public SmoothingEvalBase {
+class SmoothingEval1 : public FixedLagEvalBase {
 
 public:
 
@@ -51,33 +52,579 @@ public:
 
         //create the backward smoothing filter
         bf = new K::BackwardSimulation<MyState>(500);
+        bf->setSampler( std::unique_ptr<K::CumulativeSampler<MyState>>(new K::CumulativeSampler<MyState>()));
 
 
 	}
 
 
-    void fixedIntervallSimpleTrans() {
+    void fixedIntervallSimpleTransPath1() {
 
-        runName = "fixedIntervallSimpleTrans";
+        runName = "fixedIntervallSimpleTransPath1";
         bool smoothing_resample = false;
         smoothing_time_delay = 1;
 
-        BarometerEvaluation::barometerSigma = 0.105;
+        BarometerEvaluation::barometerSigma = 0.10;
         sr = new SensorReader("./measurements/bergwerk/path1/nexus/vor/1454775984079.csv"); // forward
         srt = new SensorReaderTurn("./measurements/bergwerk/path1/nexus/vor/Turns.txt");
         srs = new SensorReaderStep("./measurements/bergwerk/path1/nexus/vor/Steps2.txt");
 		gtw = getGroundTruthWay(*sr, floors.gtwp, path1dbl);
 
-		GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path1dbl.back()]) );
-		pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionSimple>( new MySmoothingTransitionSimple()) );
+
+	}
+
+    void fixedIntervallSimpleTransPath4(){
+
+        runName = "fixedIntervallSimpleTransPath4";
+
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path4/nexus/vor/1454776525797.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path4/nexus/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path4/nexus/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path4dbl);
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+
+        //Smoothing Variables
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 15.0;
+        smoothing_baro_sigma = 0.05;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    // ============================================================ Dijkstra ============================================== //
+
+    // Hier dauert sehr laaaaaaaannnnnnnggge @Frank
+    void fixedIntervallDijkstraTransPath4(){
+
+        runName = "fixedIntervallSimpleTrans";
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path4/nexus/1454776525797.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path4/nexus/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path4/nexus/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path4dbl);
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
 
         //Smoothing using Simple Trans
         bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
         if(smoothing_resample)
             bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
         bf->setTransition(std::unique_ptr<MySmoothingTransition>( new MySmoothingTransition(&grid)) );
+    }
 
-	}
+
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+    /* ----------------------------------------------- Bergwerk ------ Fusion 2016 --------------------------------------------------- */
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path1_nexus() {
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path1/nexus/vor/1454775984079.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path1/nexus/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path1/nexus/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path1dbl);
+
+        //Smoothing Variables
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 15.0;
+        smoothing_baro_sigma = 0.05;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path1_nexus_simple() {
+        runName = "bergwerk_path1_nexus_simple_fixedlag";
+        bergwerk_path1_nexus();
+
+        for (auto& n : grid) {n.imp = 1;}
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+
+    void bergwerk_path1_nexus_imp() {
+
+        runName = "bergwerk_path1_nexus_importance_fixedlag";
+        bergwerk_path1_nexus();
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path1_nexus_multi() {
+
+        runName = "bergwerk_path1_nexus_multi_fixedlag";
+        bergwerk_path1_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path1dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path1_nexus_shortest() {
+
+        runName = "bergwerk_path1_nexus_shortest_fixedlag";
+        bergwerk_path1_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path1dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path2_nexus() {
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path2/nexus/vor/1454779863041.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path2/nexus/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path2/nexus/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path2dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.05;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path2_nexus_simple() {
+
+        runName = "bergwerk_path2_nexus_simple_fixedlag";
+        bergwerk_path2_nexus();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+
+    void bergwerk_path2_nexus_imp() {
+
+        runName = "bergwerk_path2_nexus_importance_fixedlag";
+        bergwerk_path2_nexus();
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path2_nexus_multi() {
+
+        runName = "bergwerk_path2_nexus_multi_fixedlag";
+        bergwerk_path2_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path2dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path2_nexus_shortest() {
+
+        runName = "bergwerk_path2_nexus_shortest_fixedlag";
+        bergwerk_path2_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path2dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        walk->times = 4;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path3_nexus() {
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path3/nexus/vor/1454782562231.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path3/nexus/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path3/nexus/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path3dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.05;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path3_nexus_simple() {
+
+        runName = "bergwerk_path3_nexus_simple_fixedlag";
+        bergwerk_path3_nexus();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+
+    void bergwerk_path3_nexus_imp() {
+
+        runName = "bergwerk_path3_nexus_importance_fixedlag";
+        bergwerk_path3_nexus();
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path3_nexus_multi() {
+
+        runName = "bergwerk_path3_nexus_multi_fixedlag";
+        bergwerk_path3_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path3dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path3_nexus_shortest() {
+
+        runName = "bergwerk_path3_nexus_shortest_fixedlag";
+        bergwerk_path3_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path3dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path4_nexus() {
+        BarometerEvaluation::barometerSigma = 0.10;
+        sr = new SensorReader("./measurements/bergwerk/path4/nexus/vor/1454776525797.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path4/nexus/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path4/nexus/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path4dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.05;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path4_nexus_simple() {
+
+        runName = "bergwerk_path4_nexus_simple_fixedlag";
+        bergwerk_path4_nexus();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+
+    void bergwerk_path4_nexus_imp() {
+
+        runName = "bergwerk_path4_nexus_importance_fixedlag";
+        bergwerk_path4_nexus();
+
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path4_nexus_multi() {
+
+        runName = "bergwerk_path4_nexus_multi_fixedlag";
+        bergwerk_path4_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    void bergwerk_path4_nexus_shortest() {
+
+        runName = "bergwerk_path4_nexus_shortest_fixedlag";
+        bergwerk_path4_nexus();
+
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path1_galaxy() {
+        BarometerEvaluation::barometerSigma = 0.20;
+        stepSize = 0.9;
+        sr = new SensorReader("./measurements/bergwerk/path1/galaxy/vor/1454776168794.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path1/galaxy/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path1/galaxy/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path1dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.15;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path1_galaxy_simple() {
+        runName = "bergwerk_path1_galaxy_simple_fixedlag";
+        bergwerk_path1_galaxy();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path1_galaxy_multi() {
+        runName = "bergwerk_path1_galaxy_multi_fixedlag";
+        bergwerk_path1_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path1dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path1_galaxy_shortest() {
+        runName = "bergwerk_path1_galaxy_shortest_fixedlag";
+        bergwerk_path1_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path1dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path2_galaxy() {
+        BarometerEvaluation::barometerSigma = 0.20;
+        stepSize = 0.9;
+        sr = new SensorReader("./measurements/bergwerk/path2/galaxy/vor/1454780113404.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path2/galaxy/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path2/galaxy/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path2dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.15;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path2_galaxy_simple() {
+        runName = "bergwerk_path2_galaxy_simple_fixedlag";
+        bergwerk_path2_galaxy();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path2_galaxy_multi() {
+        runName = "bergwerk_path2_galaxy_multi_fixedlag";
+        bergwerk_path2_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path2dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path2_galaxy_shortest() {
+        runName = "bergwerk_path2_galaxy_shortest_fixedlag";
+        bergwerk_path2_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path2dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+    void bergwerk_path3_galaxy() {
+        BarometerEvaluation::barometerSigma = 0.20;
+        stepSize = 0.9;
+        sr = new SensorReader("./measurements/bergwerk/path3/galaxy/vor/1454782896548.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path3/galaxy/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path3/galaxy/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path3dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.15;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path3_galaxy_simple() {
+        runName = "bergwerk_path3_galaxy_simple_fixedlag";
+        bergwerk_path3_galaxy();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path3_galaxy_multi() {
+        runName = "bergwerk_path3_galaxy_multi_fixedlag";
+        bergwerk_path3_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path3dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path3_galaxy_shortest() {
+        runName = "bergwerk_path3_galaxy_shortest_fixedlag";
+        bergwerk_path3_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path3dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+
+    /* ------------------------------------------------------------------------------------------------------------------------------- */
+
+
+    void bergwerk_path4_galaxy() {
+        BarometerEvaluation::barometerSigma = 0.20;
+        stepSize = 0.9;
+        sr = new SensorReader("./measurements/bergwerk/path4/galaxy/vor/1454779020844.csv"); // forward
+        srt = new SensorReaderTurn("./measurements/bergwerk/path4/galaxy/vor/Turns.txt");
+        srs = new SensorReaderStep("./measurements/bergwerk/path4/galaxy/vor/Steps2.txt");
+        gtw = getGroundTruthWay(*sr, floors.gtwp, path4dbl);
+
+        smoothing_walk_mu = 0.7;
+        smoothing_walk_sigma = 0.5;
+        smoothing_heading_sigma = 5.0;
+        smoothing_baro_sigma = 0.15;
+
+        bool smoothing_resample = false;
+        smoothing_time_delay = 1;
+
+        //Smoothing using Simple Trans
+        bf->setEstimation(std::unique_ptr<K::ParticleFilterEstimationWeightedAverage<MyState>>(new K::ParticleFilterEstimationWeightedAverage<MyState>()));
+        if(smoothing_resample)
+            bf->setResampling( std::unique_ptr<K::ParticleFilterResamplingSimple<MyState>>(new K::ParticleFilterResamplingSimple<MyState>()) );
+        bf->setTransition(std::unique_ptr<MySmoothingTransitionExperimental>( new MySmoothingTransitionExperimental()) );
+    }
+
+    void bergwerk_path4_galaxy_simple() {
+        runName = "bergwerk_path4_galaxy_simple_fixedlag";
+        bergwerk_path4_galaxy();
+        for (auto& n : grid) {n.imp = 1;}	// remove importance
+        GridWalkSimpleControl<MyGridNode>* walk = new GridWalkSimpleControl<MyGridNode>();
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path4_galaxy_multi() {
+        runName = "bergwerk_path4_galaxy_multi_fixedlag";
+        bergwerk_path4_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        GridWalkPathControl<MyGridNode>* walk = new GridWalkPathControl<MyGridNode>(grid, DijkstraMapper(grid), end);
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+    }
+
+    void bergwerk_path4_galaxy_shortest() {
+
+        runName = "bergwerk_path4_galaxy_shortest_fixedlag";
+        bergwerk_path4_galaxy();
+        MyGridNode& end = (MyGridNode&)grid.getNodeFor( conv(floors.gtwp[path4dbl.back()]) );
+        DebugShortestPath<MyGridNode>* walk = new DebugShortestPath<MyGridNode>(grid, DijkstraMapper(grid), end, this->floors);
+        //walk->times = 2;
+        walk->pOther = 0.15;
+        pf->setTransition( std::unique_ptr<MyTransition>( new MyTransition(grid, *walk)) );
+
+    }
 
 
 };

code/lukas/TurnObservation.h

@@ -11,7 +11,7 @@ struct TurnObservation {
     float delta_motion; //measured change of motion direction (given by PCA)
 
     TurnObservation() {;}
-	TurnObservation(const float delta_heading, const float motion_angle) : delta_heading(delta_heading), delta_motion(motion_angle) {;}
+    TurnObservation(const float delta_heading, const float motion_angle) : delta_heading(delta_heading), delta_motion(motion_angle) {;}
 
 };
 

code/main.cpp

@@ -89,57 +89,47 @@ int main(void) {
 
 //	testModelWalk();
     SmoothingEval1 eval;
-    eval.fixedIntervallSimpleTrans();
+    eval.fixedIntervallSimpleTransPath4();
     eval.run();
 
-//	Eval1 eval;
-//	//eval.path2_forward_simple();
-//	//eval.path2_forward_path();
-//	//eval.path3_forward_simple();
-//	//eval.path3_forward_path();
 
-//	//eval.path4_nexus_simple();
+//    {SmoothingEval1 eval; eval.bergwerk_path1_nexus_simple();		eval.run();}
-//	//eval.path4_nexus_imp();
+//    //{SmoothingEval1 eval; eval.bergwerk_path1_nexus_imp();			eval.run();}
-//	//eval.path4_nexus_path();
+//    {SmoothingEval1 eval; eval.bergwerk_path1_nexus_multi();		eval.run();}
-//	//eval.path4_nexus_path_b();
+//    {SmoothingEval1 eval; eval.bergwerk_path1_nexus_shortest();		eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path1_nexus_simple();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_nexus_simple();		eval.run();}
-//	//{Eval1 eval; eval.bergwerk_path1_nexus_imp();			eval.run();}
+//    //{SmoothingEval1 eval; eval.bergwerk_path2_nexus_imp();			eval.run();}
-//	{Eval1 eval; eval.bergwerk_path1_nexus_multi();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_nexus_multi();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path1_nexus_shortest();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_nexus_shortest();		eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path2_nexus_simple();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_nexus_simple();		eval.run();}
-//	//{Eval1 eval; eval.bergwerk_path2_nexus_imp();			eval.run();}
+//    //{SmoothingEval1 eval; eval.bergwerk_path3_nexus_imp();			eval.run();}
-//	{Eval1 eval; eval.bergwerk_path2_nexus_multi();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_nexus_multi();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path2_nexus_shortest();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_nexus_shortest();		eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path3_nexus_simple();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_nexus_simple();		eval.run();}
-//	//{Eval1 eval; eval.bergwerk_path3_nexus_imp();			eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_nexus_imp();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path3_nexus_multi();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_nexus_multi();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path3_nexus_shortest();		eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_nexus_shortest();	eval.run();}
-
-//	{Eval1 eval; eval.bergwerk_path4_nexus_simple();		eval.run();}
-	//{Eval1 eval; eval.bergwerk_path4_nexus_imp();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path4_nexus_multi();		eval.run();}
-//	{Eval1 eval; eval.bergwerk_path4_nexus_shortest();	eval.run();}
 
 
 
-//	{Eval1 eval; eval.bergwerk_path1_galaxy_simple();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path1_galaxy_simple();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path1_galaxy_multi();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path1_galaxy_multi();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path1_galaxy_shortest();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path1_galaxy_shortest();	eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path2_galaxy_simple();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_galaxy_simple();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path2_galaxy_multi();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_galaxy_multi();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path2_galaxy_shortest();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path2_galaxy_shortest();	eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path3_galaxy_simple();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_galaxy_simple();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path3_galaxy_multi();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_galaxy_multi();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path3_galaxy_shortest();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path3_galaxy_shortest();	eval.run();}
 
-//	{Eval1 eval; eval.bergwerk_path4_galaxy_simple();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_galaxy_simple();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path4_galaxy_multi();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_galaxy_multi();	eval.run();}
-//	{Eval1 eval; eval.bergwerk_path4_galaxy_shortest();	eval.run();}
+//    {SmoothingEval1 eval; eval.bergwerk_path4_galaxy_shortest();	eval.run();}
 
 
 

code/particles/MyEvaluation.h

@@ -77,6 +77,9 @@ public:
 
 			if (useTurn) {
 				weight *= turnEval.getProbability(p.state, observation.turn, true);
+
+                //set
+                p.state.measurement_angle = observation.turn->delta_heading;
 			}
 
 			// set and accumulate

code/particles/MyState.h

@@ -29,6 +29,9 @@ struct MyState {
     // save last hPa measurement for the smoothing process
     double measurement_pressure;
 
+    // save last angle measurement for the smoothing process
+    double measurement_angle;
+
 	//int distanceWalkedCM;
 
 

code/particles/smoothing/MySmoothingTransition.h

@@ -0,0 +1,143 @@
+#ifndef MYSMOOTHINGTRANSITION_H
+#define MYSMOOTHINGTRANSITION_H
+
+#include <KLib/math/filter/particles/ParticleFilterTransition.h>
+#include <KLib/math/filter/smoothing/BackwardFilterTransition.h>
+#include <KLib/math/distribution/Normal.h>
+#include <KLib/math/distribution/Uniform.h>
+
+#include <Indoor/nav/dijkstra/Dijkstra.h>
+#include <Indoor/grid/Grid.h>
+
+#include "../MyState.h"
+#include "../MyControl.h"
+
+#include "../../DijkstraMapper.h"
+
+#include "../../toni/barometric.h"
+#include <map>
+
+static double smoothing_walk_mu = 0.7;
+static double smoothing_walk_sigma = 0.5;
+static double smoothing_heading_sigma = 15.0;
+static double smoothing_baro_sigma = 0.2;
+
+class MySmoothingTransition : public K::BackwardFilterTransition<MyState> {
+
+private:
+
+    /** the created grid to draw transitions from */
+    Grid<MyGridNode>* grid;
+
+	/** a simple normal distribution */
+	K::NormalDistribution distWalk;
+
+
+public:
+
+	/**
+	 * ctor
+	 * @param choice the choice to use for randomly drawing nodes
+	 * @param fp the underlying floorplan
+	 */
+    MySmoothingTransition(Grid<MyGridNode>* grid) :
+        grid(grid), distWalk(smoothing_walk_mu, smoothing_walk_sigma) {
+        distWalk.setSeed(4321);
+	}
+
+public:
+
+	uint64_t ts = 0;
+	uint64_t deltaMS = 0;
+
+	/** set the current time in millisconds */
+	void setCurrentTime(const uint64_t ts) {
+		if (this->ts == 0) {
+			this->ts = ts;
+			deltaMS = 0;
+		} else {
+            deltaMS = this->ts - ts;
+			this->ts = ts;
+		}
+	}
+
+    /**
+     * smoothing transition starting at T with t, t-1,...0
+     * @param particles_new p_t (Forward Filter)
+     * @param particles_old p_t+1 (Smoothed Particles from Step before)
+     */
+    std::vector<std::vector<double>> transition(std::vector<K::Particle<MyState>>const& particles_new,
+                                                std::vector<K::Particle<MyState>>const& particles_old ) override {
+
+
+        // calculate alpha(m,n) = p(q_t+1(m) | q_t(n))
+        // this means, predict all possible states q_t+1 with all passible states q_t
+        // e.g. p(q_490(1)|q_489(1));p(q_490(1)|q_489(2)) ... p(q_490(1)|q_489(N)) and
+        // p(q_490(1)|q_489(1)); p(q_490(2)|q_489(1)) ... p(q_490(M)|q_489(1))
+        std::vector<std::vector<double>> predictionProbabilities;
+
+        auto p1 = particles_old.begin();
+        auto p2 = particles_new.begin();
+
+        #pragma omp parallel for private(p2) shared(predictionProbabilities)
+        for (p1 = particles_old.begin(); p1 < particles_old.end(); ++p1) {
+            std::vector<double> innerVector;
+            for(p2 = particles_new.begin(); p2 < particles_new.end(); ++p2){
+
+                // find the node (square) the particle is within
+                // just to be safe, we round z to the nearest floor
+
+                //TODO:: Nullptr check! sometimes src/dst can be nullptr
+                //const Node3* dst = graph->getNearestNode(p1->state.x_cm, p1->state.y_cm, std::round(p1->state.z_nr));
+                //const Node3* src = graph->getNearestNode(p2->state.x_cm, p2->state.y_cm, std::round(p2->state.z_nr));
+
+                const MyGridNode* dst = grid->getNodePtrFor(GridPoint(p1->state.pCur.x, p1->state.pCur.y, p1->state.pCur.z));
+                const MyGridNode* src = grid->getNodePtrFor(GridPoint(p2->state.pCur.x, p2->state.pCur.y, p2->state.pCur.z));
+
+                Dijkstra<MyGridNode> dijkstra;
+                dijkstra.build(src, dst, DijkstraMapper(*grid));
+
+                double distDijkstra_m = dijkstra.getNode(*src)->cumWeight;
+
+                const double distProb = distWalk.getProbability(distDijkstra_m);
+
+                //getProb using the angle(heading) between src and dst
+                double angle = 0.0;
+                if(!(p2->state.pCur.x == p1->state.pCur.x) && !(p2->state.pCur.y == p1->state.pCur.y)){
+                    angle = Angle::getDEG_360(p2->state.pCur.x, p2->state.pCur.y, p1->state.pCur.x, p1->state.pCur.y);
+                }
+                const double headingProb = K::NormalDistribution::getProbability(p1->state.cumulativeHeading, smoothing_heading_sigma, angle);
+
+                //assert(headingProb != 0.0);
+                //assert(distProb != 0.0);
+
+                //check how near we are to the measurement
+                double floorProb = K::NormalDistribution::getProbability(p1->state.measurement_pressure, smoothing_baro_sigma, p2->state.hPa);
+
+                //combine the probabilities
+                double prob = distProb * floorProb * headingProb;
+                innerVector.push_back(prob);
+
+                //if(distance_m != distance_m) {throw "detected NaN";}
+                //if(distProb != distProb) {throw "detected NaN";}
+                if(angle != angle) {throw "detected NaN";}
+                if(headingProb != headingProb) {throw "detected NaN";}
+                if(floorProb != floorProb) {throw "detected NaN";}
+                if(floorProb == 0) {throw "detected NaN";}
+                if(prob != prob) {throw "detected NaN";}
+
+                //assert(prob != 0.0);
+
+
+            }
+            #pragma omp critical
+            predictionProbabilities.push_back(innerVector);
+        }
+        return predictionProbabilities;
+
+    }
+
+
+};
+
+#endif // MYTRANSITION_H

code/particles/smoothing/MySmoothingTransitionExperimental.h

@@ -0,0 +1,125 @@
+#ifndef MYSMOOTHINGTRANSITIONEXPERIMENTAL_H
+#define MYSMOOTHINGTRANSITIONEXPERIMENTAL_H
+
+#include <KLib/math/filter/particles/ParticleFilterTransition.h>
+#include <KLib/math/filter/smoothing/BackwardFilterTransition.h>
+#include <KLib/math/distribution/Normal.h>
+#include <KLib/math/distribution/Uniform.h>
+
+#include <Indoor/geo/Angle.h>
+
+#include "../MyState.h"
+#include "../MyControl.h"
+#include "../../Helper.h"
+#include "../../toni/barometric.h"
+
+class MySmoothingTransitionExperimental : public K::BackwardFilterTransition<MyState> {
+
+private:
+
+	/** a simple normal distribution */
+	K::NormalDistribution distWalk;
+
+
+public:
+
+	/**
+	 * ctor
+	 * @param choice the choice to use for randomly drawing nodes
+	 * @param fp the underlying floorplan
+	 */
+    MySmoothingTransitionExperimental() :
+        distWalk(smoothing_walk_mu, smoothing_walk_sigma) {
+        distWalk.setSeed(4321);
+	}
+
+public:
+
+	uint64_t ts = 0;
+	uint64_t deltaMS = 0;
+
+	/** set the current time in millisconds */
+	void setCurrentTime(const uint64_t ts) {
+		if (this->ts == 0) {
+			this->ts = ts;
+			deltaMS = 0;
+		} else {
+            deltaMS = this->ts - ts;
+			this->ts = ts;
+		}
+	}
+
+    /**
+     * smoothing transition starting at T with t, t-1,...0
+     * @param particles_new p_t (Forward Filter)
+     * @param particles_old p_t+1 (Smoothed Particles from Step before)
+     */
+    std::vector<std::vector<double>> transition(std::vector<K::Particle<MyState>>const& particles_new,
+                                                std::vector<K::Particle<MyState>>const& particles_old ) override {
+
+
+        // calculate alpha(m,n) = p(q_t+1(m) | q_t(n))
+        // this means, predict all possible states q_t+1 with all passible states q_t
+        // e.g. p(q_490(1)|q_489(1));p(q_490(1)|q_489(2)) ... p(q_490(1)|q_489(N)) and
+        // p(q_490(1)|q_489(1)); p(q_490(2)|q_489(1)) ... p(q_490(M)|q_489(1))
+        std::vector<std::vector<double>> predictionProbabilities;
+
+        auto p1 = particles_old.begin(); //smoothed / backward filter p_t+1
+        auto p2 = particles_new.begin(); //forward filter p_t
+
+        #pragma omp parallel for private(p2) shared(predictionProbabilities)
+        for (p1 = particles_old.begin(); p1 < particles_old.end(); ++p1) {
+            std::vector<double> innerVector;
+            for(p2 = particles_new.begin(); p2 < particles_new.end(); ++p2){
+
+                //!!!distance kann hier zu groß werden!!!
+                const double distance_m = p2->state.pCur.getDistance(p1->state.pCur) / 100.0;
+
+                //get distance walked and getProb using the walking model
+                //double distDijkstra_m = ((GRID_DISTANCE_CM / 100.0) * (8 - 1));
+                const double distProb = distWalk.getProbability(distance_m);
+
+
+                //getProb using the angle(heading) between src and dst
+                double angle = 0.0;
+                if(!(p2->state.pCur.x == p1->state.pCur.x) && !(p2->state.pCur.y == p1->state.pCur.y)){
+                    angle = Angle::getDEG_360(p2->state.pCur.x, p2->state.pCur.y, p1->state.pCur.x, p1->state.pCur.y);
+                }
+
+                const double headingProb = K::NormalDistribution::getProbability(p1->state.cumulativeHeading, smoothing_heading_sigma, angle);
+
+                //assert(headingProb != 0.0);
+                //assert(distProb != 0.0);
+
+
+                //check how near we are to the measurement
+                double floorProb = K::NormalDistribution::getProbability(p1->state.measurement_pressure, smoothing_baro_sigma, p2->state.hPa);
+
+
+                //combine the probabilities
+                double prob = distProb * headingProb * floorProb;
+                innerVector.push_back(prob);
+
+                if(distance_m != distance_m) {throw "detected NaN";}
+                if(distProb != distProb) {throw "detected NaN";}
+                if(angle != angle) {throw "detected NaN";}
+                if(headingProb != headingProb) {throw "detected NaN";}
+                if(floorProb != floorProb) {throw "detected NaN";}
+                if(floorProb == 0) {throw "detected NaN";}
+                if(prob != prob) {throw "detected NaN";}
+
+                //assert(prob != 0.0);
+
+
+            }
+            #pragma omp critical
+            predictionProbabilities.push_back(innerVector);
+        }
+        return predictionProbabilities;
+
+    }
+
+
+};
+
+#endif // MYTRANSITION_H

code/particles/smoothing/MySmoothingTransitionSimple.h

@@ -0,0 +1,125 @@
+#ifndef MYSMOOTHINGTRANSITIONSIMPLE_H
+#define MYSMOOTHINGTRANSITIONSIMPLE_H
+
+#include <KLib/math/filter/particles/ParticleFilterTransition.h>
+#include <KLib/math/filter/smoothing/BackwardFilterTransition.h>
+#include <KLib/math/distribution/Normal.h>
+#include <KLib/math/distribution/Uniform.h>
+
+#include <Indoor/geo/Angle.h>
+
+#include "../MyState.h"
+#include "../MyControl.h"
+#include "../../Helper.h"
+#include "../../toni/barometric.h"
+
+class MySmoothingTransitionSimple : public K::BackwardFilterTransition<MyState> {
+
+private:
+
+	/** a simple normal distribution */
+	K::NormalDistribution distWalk;
+
+
+public:
+
+	/**
+	 * ctor
+	 * @param choice the choice to use for randomly drawing nodes
+	 * @param fp the underlying floorplan
+	 */
+    MySmoothingTransitionSimple() :
+        distWalk(smoothing_walk_mu, smoothing_walk_sigma) {
+        distWalk.setSeed(4321);
+	}
+
+public:
+
+	uint64_t ts = 0;
+	uint64_t deltaMS = 0;
+
+	/** set the current time in millisconds */
+	void setCurrentTime(const uint64_t ts) {
+		if (this->ts == 0) {
+			this->ts = ts;
+			deltaMS = 0;
+		} else {
+            deltaMS = this->ts - ts;
+			this->ts = ts;
+		}
+	}
+
+    /**
+     * smoothing transition starting at T with t, t-1,...0
+     * @param particles_new p_t (Forward Filter)
+     * @param particles_old p_t+1 (Smoothed Particles from Step before)
+     */
+    std::vector<std::vector<double>> transition(std::vector<K::Particle<MyState>>const& particles_new,
+                                                std::vector<K::Particle<MyState>>const& particles_old ) override {
+
+
+        // calculate alpha(m,n) = p(q_t+1(m) | q_t(n))
+        // this means, predict all possible states q_t+1 with all passible states q_t
+        // e.g. p(q_490(1)|q_489(1));p(q_490(1)|q_489(2)) ... p(q_490(1)|q_489(N)) and
+        // p(q_490(1)|q_489(1)); p(q_490(2)|q_489(1)) ... p(q_490(M)|q_489(1))
+        std::vector<std::vector<double>> predictionProbabilities;
+
+        auto p1 = particles_old.begin(); //smoothed / backward filter p_t+1
+        auto p2 = particles_new.begin(); //forward filter p_t
+
+        #pragma omp parallel for private(p2) shared(predictionProbabilities)
+        for (p1 = particles_old.begin(); p1 < particles_old.end(); ++p1) {
+            std::vector<double> innerVector;
+            for(p2 = particles_new.begin(); p2 < particles_new.end(); ++p2){
+
+                //!!!distance kann hier zu groß werden!!!
+                const double distance_m = p2->state.pCur.getDistance(p1->state.pCur) / 100.0;
+
+                //get distance walked and getProb using the walking model
+                //double distDijkstra_m = ((GRID_DISTANCE_CM / 100.0) * (8 - 1));
+                const double distProb = distWalk.getProbability(distance_m);
+
+
+                //getProb using the angle(heading) between src and dst
+                double angle = 0.0;
+                if(!(p2->state.pCur.x == p1->state.pCur.x) && !(p2->state.pCur.y == p1->state.pCur.y)){
+                    angle = Angle::getDEG_360(p2->state.pCur.x, p2->state.pCur.y, p1->state.pCur.x, p1->state.pCur.y);
+                }
+
+                const double headingProb = K::NormalDistribution::getProbability(p1->state.cumulativeHeading, smoothing_heading_sigma, angle);
+
+                //assert(headingProb != 0.0);
+                //assert(distProb != 0.0);
+
+
+                //check how near we are to the measurement
+                double floorProb = K::NormalDistribution::getProbability(p1->state.measurement_pressure, smoothing_baro_sigma, p2->state.hPa);
+
+
+                //combine the probabilities
+                double prob = distProb * headingProb * floorProb;
+                innerVector.push_back(prob);
+
+                if(distance_m != distance_m) {throw "detected NaN";}
+                if(distProb != distProb) {throw "detected NaN";}
+                if(angle != angle) {throw "detected NaN";}
+                if(headingProb != headingProb) {throw "detected NaN";}
+                if(floorProb != floorProb) {throw "detected NaN";}
+                if(floorProb == 0) {throw "detected NaN";}
+                if(prob != prob) {throw "detected NaN";}
+
+                //assert(prob != 0.0);
+
+
+            }
+            #pragma omp critical
+            predictionProbabilities.push_back(innerVector);
+        }
+        return predictionProbabilities;
+
+    }
+
+
+};
+
+#endif // MYTRANSITION_H

tex/IEEEabrv.bib

@@ -0,0 +1,447 @@
+
+IEEEabrv.bib
+V1.12 (2007/01/11)
+Copyright (c) 2002-2007 by Michael Shell
+See: http://www.michaelshell.org/
+for current contact information.
+
+BibTeX bibliography string definitions of the ABBREVIATED titles of
+IEEE journals and magazines and online publications.
+
+This file is designed for bibliography styles that require 
+abbreviated titles and is not for use in bibliographies that
+require full-length titles.
+
+Support sites:
+http://www.michaelshell.org/tex/ieeetran/
+http://www.ctan.org/tex-archive/macros/latex/contrib/IEEEtran/
+and/or
+http://www.ieee.org/
+
+Special thanks to Laura Hyslop and ken Rawson of IEEE for their help
+in obtaining the information needed to compile this file. Also,
+Volker Kuhlmann and Moritz Borgmann kindly provided some corrections
+and additions.
+
+*************************************************************************
+Legal Notice:
+This code is offered as-is without any warranty either expressed or
+implied; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE! 
+User assumes all risk.
+In no event shall IEEE or any contributor to this code be liable for
+any damages or losses, including, but not limited to, incidental,
+consequential, or any other damages, resulting from the use or misuse
+of any information contained here.
+
+All comments are the opinions of their respective authors and are not
+necessarily endorsed by the IEEE.
+
+This work is distributed under the LaTeX Project Public License (LPPL)
+( http://www.latex-project.org/ ) version 1.3, and may be freely used,
+distributed and modified. A copy of the LPPL, version 1.3, is included
+in the base LaTeX documentation of all distributions of LaTeX released
+2003/12/01 or later.
+Retain all contribution notices and credits.
+** Modified files should be clearly indicated as such, including  **
+** renaming them and changing author support contact information. **
+
+File list of work: IEEEabrv.bib, IEEEfull.bib, IEEEexample.bib,
+                   IEEEtran.bst, IEEEtranS.bst, IEEEtranSA.bst,
+                   IEEEtranN.bst, IEEEtranSN.bst, IEEEtran_bst_HOWTO.pdf
+*************************************************************************
+
+
+USAGE:
+
+\bibliographystyle{mybstfile}
+\bibliography{IEEEabrv,mybibfile}
+
+where the IEEE titles in the .bib database entries use the strings
+defined here. e.g.,
+
+
+   journal = IEEE_J_AC,
+
+
+to yield "{IEEE} Trans. Automat. Contr."
+
+
+IEEE uses abbreviated journal titles in their bibliographies -
+this file is suitable for work that is to be submitted to the IEEE.
+
+
+For work that requires full-length titles, you should use the full
+titles provided in the companion file, IEEEfull.bib.
+
+
+** NOTES **
+
+ 1. Journals have been grouped according to subject in order to make it
+    easier to locate and extract the definitions for related journals - 
+    as most works use references that are confined to a single topic.
+    Magazines are listed in straight alphabetical order.
+
+ 2. String names are closely based on IEEE's own internal acronyms.
+ 
+ 3. Abbreviations follow IEEE's style.
+
+ 4. Older, out-of-print IEEE titles are included (but not including titles
+    dating prior to IEEE's formation from the IRE and AIEE in 1963).
+
+ 5. The following NEW/current journal definitions have been disabled because
+    their abbreviations have not yet been verified:
+    
+    STRING{IEEE_J_CBB        = "{IEEE/ACM} Trans. Comput. Biology Bioinformatics"}
+    STRING{IEEE_J_CJECE      = "Canadian J. Elect. Comput. Eng."}
+    STRING{IEEE_J_DSC        = "{IEEE} Trans. Dependable Secure Comput."}
+    STRING{IEEE_O_DSO        = "{IEEE} Distrib. Syst. Online"}
+    
+ 6. The following OLD journal definitions have been disabled because
+    their abbreviations have not yet been found/verified:
+
+    STRING{IEEE_J_BCTV       = "{IEEE} Trans. Broadcast Television Receivers"}
+    STRING{IEEE_J_EWS        = "{IEEE} Trans. Eng. Writing Speech"}
+
+If you know what the proper abbreviation is for a string in #5 or #6 above,
+email me and I will correct them in the next release.
+
+
+
+
+
+IEEE Journals 
+
+
+
+aerospace and military
+@STRING{IEEE_J_AES        = "{IEEE} Trans. Aerosp. Electron. Syst."}
+@STRING{IEEE_J_ANE        = "{IEEE} Trans. Aerosp. Navig. Electron."}
+@STRING{IEEE_J_ANNE       = "{IEEE} Trans. Aeronaut. Navig. Electron."}
+@STRING{IEEE_J_AS         = "{IEEE} Trans. Aerosp."}
+@STRING{IEEE_J_AIRE       = "{IEEE} Trans. Airborne Electron."}
+@STRING{IEEE_J_MIL        = "{IEEE} Trans. Mil. Electron."}
+
+
+
+autos, transportation and vehicles (non-aerospace)
+@STRING{IEEE_J_ITS        = "{IEEE} Trans. Intell. Transp. Syst."}
+@STRING{IEEE_J_VT         = "{IEEE} Trans. Veh. Technol."}
+@STRING{IEEE_J_VC         = "{IEEE} Trans. Veh. Commun."}
+
+
+
+circuits, signals, systems, audio and controls
+@STRING{IEEE_J_SPL        = "{IEEE} Signal Process. Lett."}
+@STRING{IEEE_J_ASSP       = "{IEEE} Trans. Acoust., Speech, Signal Process."}
+@STRING{IEEE_J_AU         = "{IEEE} Trans. Audio"}
+@STRING{IEEE_J_AUEA       = "{IEEE} Trans. Audio Electroacoust."}
+@STRING{IEEE_J_AC         = "{IEEE} Trans. Autom. Control"}
+@STRING{IEEE_J_CAS        = "{IEEE} Trans. Circuits Syst."}
+@STRING{IEEE_J_CASVT      = "{IEEE} Trans. Circuits Syst. Video Technol."}
+@STRING{IEEE_J_CASI       = "{IEEE} Trans. Circuits Syst. {I}"}
+@STRING{IEEE_J_CASII      = "{IEEE} Trans. Circuits Syst. {II}"}
+in 2004 CASI and CASII renamed part title to CASI_RP and CASII_EB, respectively.
+@STRING{IEEE_J_CASI_RP    = "{IEEE} Trans. Circuits Syst. {I}"}
+@STRING{IEEE_J_CASII_EB   = "{IEEE} Trans. Circuits Syst. {II}"}
+@STRING{IEEE_J_CT         = "{IEEE} Trans. Circuit Theory"}
+@STRING{IEEE_J_CST        = "{IEEE} Trans. Control Syst. Technol."}
+@STRING{IEEE_J_SP         = "{IEEE} Trans. Signal Process."}
+@STRING{IEEE_J_SU         = "{IEEE} Trans. Sonics Ultrason."}
+@STRING{IEEE_J_SAP        = "{IEEE} Trans. Speech Audio Process."}
+@STRING{IEEE_J_UE         = "{IEEE} Trans. Ultrason. Eng."}
+@STRING{IEEE_J_UFFC       = "{IEEE} Trans. Ultrason., Ferroelectr., Freq. Control"}
+
+
+
+communications
+@STRING{IEEE_J_COML       = "{IEEE} Commun. Lett."}
+@STRING{IEEE_J_JSAC       = "{IEEE} J. Sel. Areas Commun."}
+@STRING{IEEE_J_COM        = "{IEEE} Trans. Commun."}
+@STRING{IEEE_J_COMT       = "{IEEE} Trans. Commun. Technol."}
+@STRING{IEEE_J_WCOM       = "{IEEE} Trans. Wireless Commun."}
+
+
+
+components, packaging and manufacturing
+@STRING{IEEE_J_ADVP       = "{IEEE} Trans. Adv. Packag."}
+@STRING{IEEE_J_CHMT       = "{IEEE} Trans. Compon., Hybrids, Manuf. Technol."}
+@STRING{IEEE_J_CPMTA      = "{IEEE} Trans. Compon., Packag., Manuf. Technol. {A}"}
+@STRING{IEEE_J_CPMTB      = "{IEEE} Trans. Compon., Packag., Manuf. Technol. {B}"}
+@STRING{IEEE_J_CPMTC      = "{IEEE} Trans. Compon., Packag., Manuf. Technol. {C}"}
+@STRING{IEEE_J_CAPT       = "{IEEE} Trans. Compon. Packag. Technol."}
+@STRING{IEEE_J_CAPTS      = "{IEEE} Trans. Compon. Packag. Technol."}
+@STRING{IEEE_J_CPART      = "{IEEE} Trans. Compon. Parts"}
+@STRING{IEEE_J_EPM        = "{IEEE} Trans. Electron. Packag. Manuf."}
+@STRING{IEEE_J_MFT        = "{IEEE} Trans. Manuf. Technol."}
+@STRING{IEEE_J_PHP        = "{IEEE} Trans. Parts, Hybrids, Packag."}
+@STRING{IEEE_J_PMP        = "{IEEE} Trans. Parts, Mater., Packag."}
+
+
+
+CAD
+@STRING{IEEE_J_TCAD       = "{IEEE} J. Technol. Comput. Aided Design"}
+@STRING{IEEE_J_CAD        = "{IEEE} Trans. Comput.-Aided Design Integr. Circuits Syst."}
+
+
+
+coding, data, information, knowledge
+@STRING{IEEE_J_IT         = "{IEEE} Trans. Inf. Theory"}
+@STRING{IEEE_J_KDE        = "{IEEE} Trans. Knowl. Data Eng."}
+
+
+
+computers, computation, networking and software
+@STRING{IEEE_J_C          = "{IEEE} Trans. Comput."}
+@STRING{IEEE_J_CAL        = "{IEEE} Comput. Archit. Lett."}
+disabled till definition is verified
+STRING{IEEE_J_DSC         = "{IEEE} Trans. Dependable Secure Comput."}
+@STRING{IEEE_J_ECOMP      = "{IEEE} Trans. Electron. Comput."}
+@STRING{IEEE_J_EVC        = "{IEEE} Trans. Evol. Comput."}
+@STRING{IEEE_J_FUZZ       = "{IEEE} Trans. Fuzzy Syst."}
+@STRING{IEEE_J_IFS        = "{IEEE} Trans. Inf. Forensics Security"}
+@STRING{IEEE_J_MC         = "{IEEE} Trans. Mobile Comput."}
+@STRING{IEEE_J_NET        = "{IEEE/ACM} Trans. Netw."}
+@STRING{IEEE_J_NN         = "{IEEE} Trans. Neural Netw."}
+@STRING{IEEE_J_PDS        = "{IEEE} Trans. Parallel Distrib. Syst."}
+@STRING{IEEE_J_SE         = "{IEEE} Trans. Softw. Eng."}
+
+
+
+computer graphics, imaging, and multimedia
+@STRING{IEEE_J_JDT        = "{IEEE/OSA} J. Display Technol."}
+@STRING{IEEE_J_IP         = "{IEEE} Trans. Image Process."}
+@STRING{IEEE_J_MM         = "{IEEE} Trans. Multimedia"}
+@STRING{IEEE_J_VCG        = "{IEEE} Trans. Vis. Comput. Graphics"}
+
+
+
+cybernetics, ergonomics, robots, man-machine, and automation
+@STRING{IEEE_J_ASE        = "{IEEE} Trans. Autom. Sci. Eng."}
+@STRING{IEEE_J_JRA        = "{IEEE} J. Robot. Autom."}
+@STRING{IEEE_J_HFE        = "{IEEE} Trans. Hum. Factors Electron."}
+@STRING{IEEE_J_MMS        = "{IEEE} Trans. Man-Mach. Syst."}
+@STRING{IEEE_J_PAMI       = "{IEEE} Trans. Pattern Anal. Mach. Intell."}
+in 1989 JRA became RA
+in August 2004, RA split into ASE and RO
+@STRING{IEEE_J_RA         = "{IEEE} Trans. Robot. Autom."}
+@STRING{IEEE_J_RO         = "{IEEE} Trans. Robot."}
+@STRING{IEEE_J_SMC        = "{IEEE} Trans. Syst., Man, Cybern."}
+@STRING{IEEE_J_SMCA       = "{IEEE} Trans. Syst., Man, Cybern. {A}"}
+@STRING{IEEE_J_SMCB       = "{IEEE} Trans. Syst., Man, Cybern. {B}"}
+@STRING{IEEE_J_SMCC       = "{IEEE} Trans. Syst., Man, Cybern. {C}"}
+@STRING{IEEE_J_SSC        = "{IEEE} Trans. Syst. Sci. Cybern."}
+
+
+
+earth, wind, fire and water
+@STRING{IEEE_J_GE         = "{IEEE} Trans. Geosci. Electron."}
+@STRING{IEEE_J_GRS        = "{IEEE} Trans. Geosci. Remote Sens."}
+@STRING{IEEE_J_GRSL       = "{IEEE} Geosci. Remote Sens. Lett."}
+@STRING{IEEE_J_OE         = "{IEEE} J. Ocean. Eng."}
+
+
+
+education, engineering, history, IEEE, professional
+disabled till definition is verified
+STRING{IEEE_J_CJECE       = "Canadian J. Elect. Comput. Eng."}
+@STRING{IEEE_J_PROC       = "Proc. {IEEE}"}
+@STRING{IEEE_J_EDU        = "{IEEE} Trans. Educ."}
+@STRING{IEEE_J_EM         = "{IEEE} Trans. Eng. Manag."}
+disabled till definition is verified
+STRING{IEEE_J_EWS         = "{IEEE} Trans. Eng. Writing Speech"}
+@STRING{IEEE_J_PC         = "{IEEE} Trans. Prof. Commun."}
+
+
+
+electromagnetics, antennas, EMI, magnetics and microwave
+@STRING{IEEE_J_AWPL       = "{IEEE} Antennas Wireless Propag. Lett."}
+@STRING{IEEE_J_MGWL       = "{IEEE} Microw. Guided Wave Lett."}
+IEEE seems to want "Compon." here, not "Comp."
+@STRING{IEEE_J_MWCL       = "{IEEE} Microw. Wireless Compon. Lett."}
+@STRING{IEEE_J_AP         = "{IEEE} Trans. Antennas Propag."}
+@STRING{IEEE_J_EMC        = "{IEEE} Trans. Electromagn. Compat."}
+@STRING{IEEE_J_MAG        = "{IEEE} Trans. Magn."}
+@STRING{IEEE_J_MTT        = "{IEEE} Trans. Microw. Theory Tech."}
+@STRING{IEEE_J_RFI        = "{IEEE} Trans. Radio Freq. Interference"}
+@STRING{IEEE_J_TJMJ       = "{IEEE} Transl. J. Magn. Jpn."}
+
+
+
+energy and power
+@STRING{IEEE_J_EC         = "{IEEE} Trans. Energy Convers."}
+@STRING{IEEE_J_PEL        = "{IEEE} Power Electron. Lett."}
+@STRING{IEEE_J_PWRAS      = "{IEEE} Trans. Power App. Syst."}
+@STRING{IEEE_J_PWRD       = "{IEEE} Trans. Power Del."}
+@STRING{IEEE_J_PWRE       = "{IEEE} Trans. Power Electron."}
+@STRING{IEEE_J_PWRS       = "{IEEE} Trans. Power Syst."}
+
+
+
+industrial, commercial and consumer
+@STRING{IEEE_J_APPIND     = "{IEEE} Trans. Appl. Ind."}
+@STRING{IEEE_J_BC         = "{IEEE} Trans. Broadcast."}
+disabled till definition is verified
+STRING{IEEE_J_BCTV        = "{IEEE} Trans. Broadcast Television Receivers"}
+@STRING{IEEE_J_CE         = "{IEEE} Trans. Consum. Electron."}
+@STRING{IEEE_J_IE         = "{IEEE} Trans. Ind. Electron."}
+@STRING{IEEE_J_IECI       = "{IEEE} Trans. Ind. Electron. Contr. Instrum."}
+@STRING{IEEE_J_IA         = "{IEEE} Trans. Ind. Appl."}
+@STRING{IEEE_J_IGA        = "{IEEE} Trans. Ind. Gen. Appl."}
+@STRING{IEEE_J_IINF       = "{IEEE} Trans. Ind. Informat."}
+@STRING{IEEE_J_PSE        = "{IEEE} J. Product Safety Eng."}
+
+
+
+instrumentation and measurement
+@STRING{IEEE_J_IM         = "{IEEE} Trans. Instrum. Meas."}
+
+
+
+insulation and materials
+@STRING{IEEE_J_JEM        = "{IEEE/TMS} J. Electron. Mater."}
+@STRING{IEEE_J_DEI        = "{IEEE} Trans. Dielectr. Electr. Insul."}
+@STRING{IEEE_J_EI         = "{IEEE} Trans. Electr. Insul."}
+
+
+
+mechanical
+@STRING{IEEE_J_MECH       = "{IEEE/ASME} Trans. Mechatronics"}
+@STRING{IEEE_J_MEMS       = "J. Microelectromech. Syst."}
+
+
+
+medical and biological
+@STRING{IEEE_J_BME        = "{IEEE} Trans. Biomed. Eng."}
+Note: The B-ME journal later dropped the hyphen and became the BME.
+@STRING{IEEE_J_B-ME       = "{IEEE} Trans. Bio-Med. Eng."}
+@STRING{IEEE_J_BMELC      = "{IEEE} Trans. Bio-Med. Electron."}
+disabled till definition is verified
+STRING{IEEE_J_CBB         = "{IEEE/ACM} Trans. Comput. Biology Bioinformatics"}
+@STRING{IEEE_J_ITBM       = "{IEEE} Trans. Inf. Technol. Biomed."}
+@STRING{IEEE_J_ME         = "{IEEE} Trans. Med. Electron."}
+@STRING{IEEE_J_MI         = "{IEEE} Trans. Med. Imag."}
+@STRING{IEEE_J_NB         = "{IEEE} Trans. Nanobiosci."}
+@STRING{IEEE_J_NSRE       = "{IEEE} Trans. Neural Syst. Rehabil. Eng."}
+@STRING{IEEE_J_RE         = "{IEEE} Trans. Rehabil. Eng."}
+
+
+
+ optics, lightwave and photonics
+@STRING{IEEE_J_PTL        = "{IEEE} Photon. Technol. Lett."}
+@STRING{IEEE_J_JLT        = "J. Lightw. Technol."}
+
+
+
+physics, electrons, nanotechnology, nuclear and quantum electronics
+@STRING{IEEE_J_EDL        = "{IEEE} Electron Device Lett."}
+@STRING{IEEE_J_JQE        = "{IEEE} J. Quantum Electron."}
+@STRING{IEEE_J_JSTQE      = "{IEEE} J. Sel. Topics Quantum Electron."}
+@STRING{IEEE_J_ED         = "{IEEE} Trans. Electron Devices"}
+@STRING{IEEE_J_NANO       = "{IEEE} Trans. Nanotechnol."}
+@STRING{IEEE_J_NS         = "{IEEE} Trans. Nucl. Sci."}
+@STRING{IEEE_J_PS         = "{IEEE} Trans. Plasma Sci."}
+
+
+
+reliability
+IEEE seems to want "Mat." here, not "Mater."
+@STRING{IEEE_J_DMR        = "{IEEE} Trans. Device Mater. Rel."}
+@STRING{IEEE_J_R          = "{IEEE} Trans. Rel."}
+
+
+
+semiconductors, superconductors, electrochemical and solid state
+@STRING{IEEE_J_ESSL       = "{IEEE/ECS} Electrochem. Solid-State Lett."}
+@STRING{IEEE_J_JSSC       = "{IEEE} J. Solid-State Circuits"}
+@STRING{IEEE_J_ASC        = "{IEEE} Trans. Appl. Supercond."}
+@STRING{IEEE_J_SM         = "{IEEE} Trans. Semicond. Manuf."}
+
+
+
+sensors
+@STRING{IEEE_J_SENSOR     = "{IEEE} Sensors J."}
+
+
+
+VLSI
+@STRING{IEEE_J_VLSI       = "{IEEE} Trans. {VLSI} Syst."}
+
+
+
+
+
+
+IEEE Magazines 
+
+
+
+@STRING{IEEE_M_AES        = "{IEEE} Aerosp. Electron. Syst. Mag."}
+@STRING{IEEE_M_HIST       = "{IEEE} Ann. Hist. Comput."}
+@STRING{IEEE_M_AP         = "{IEEE} Antennas Propag. Mag."}
+@STRING{IEEE_M_ASSP       = "{IEEE} {ASSP} Mag."}
+@STRING{IEEE_M_CD         = "{IEEE} Circuits Devices Mag."}
+@STRING{IEEE_M_CAS        = "{IEEE} Circuits Syst. Mag."}
+@STRING{IEEE_M_COM        = "{IEEE} Commun. Mag."}
+@STRING{IEEE_M_COMSOC     = "{IEEE} Commun. Soc. Mag."}
+@STRING{IEEE_M_CIM        = "{IEEE} Comput. Intell. Mag."}
+CSEM changed to CSE in 1999
+@STRING{IEEE_M_CSE        = "{IEEE} Comput. Sci. Eng."}
+@STRING{IEEE_M_CSEM       = "{IEEE} Comput. Sci. Eng. Mag."}
+@STRING{IEEE_M_C          = "{IEEE} Computer"}
+@STRING{IEEE_M_CAP        = "{IEEE} Comput. Appl. Power"}
+@STRING{IEEE_M_CGA        = "{IEEE} Comput. Graph. Appl."}
+@STRING{IEEE_M_CONC       = "{IEEE} Concurrency"}
+@STRING{IEEE_M_CS         = "{IEEE} Control Syst. Mag."}
+@STRING{IEEE_M_DTC        = "{IEEE} Des. Test. Comput."}
+@STRING{IEEE_M_EI         = "{IEEE} Electr. Insul. Mag."}
+@STRING{IEEE_M_ETR        = "{IEEE} ElectroTechnol. Rev."}
+@STRING{IEEE_M_EMB        = "{IEEE} Eng. Med. Biol. Mag."}
+@STRING{IEEE_M_EMR        = "{IEEE} Eng. Manag. Rev."}
+@STRING{IEEE_M_EXP        = "{IEEE} Expert"}
+@STRING{IEEE_M_IA         = "{IEEE} Ind. Appl. Mag."}
+@STRING{IEEE_M_IM         = "{IEEE} Instrum. Meas. Mag."}
+@STRING{IEEE_M_IS         = "{IEEE} Intell. Syst."}
+@STRING{IEEE_M_IC         = "{IEEE} Internet Comput."}
+@STRING{IEEE_M_ITP        = "{IEEE} {IT} Prof."}
+@STRING{IEEE_M_MICRO      = "{IEEE} Micro"}
+@STRING{IEEE_M_MW         = "{IEEE} Microw. Mag."}
+@STRING{IEEE_M_MM         = "{IEEE} Multimedia"}
+@STRING{IEEE_M_NET        = "{IEEE} Netw."}
+IEEE's editorial manual lists "Pers. Commun.", 
+but "Personal Commun. Mag." seems to be what is used in the journals
+@STRING{IEEE_M_PCOM       = "{IEEE} Personal Commun. Mag."}
+@STRING{IEEE_M_POT        = "{IEEE} Potentials"}
+CAP and PER merged to form PE in 2003
+@STRING{IEEE_M_PE         = "{IEEE} Power Energy Mag."}
+@STRING{IEEE_M_PER        = "{IEEE} Power Eng. Rev."}
+@STRING{IEEE_M_PVC        = "{IEEE} Pervasive Comput."}
+@STRING{IEEE_M_RA         = "{IEEE} Robot. Autom. Mag."}
+@STRING{IEEE_M_SAP        = "{IEEE} Security Privacy"}
+@STRING{IEEE_M_SP         = "{IEEE} Signal Process. Mag."}
+@STRING{IEEE_M_S          = "{IEEE} Softw."}
+@STRING{IEEE_M_SPECT      = "{IEEE} Spectr."}
+@STRING{IEEE_M_TS         = "{IEEE} Technol. Soc. Mag."}
+@STRING{IEEE_M_VT         = "{IEEE} Veh. Technol. Mag."}
+@STRING{IEEE_M_WC         = "{IEEE} Wireless Commun. Mag."}
+@STRING{IEEE_M_TODAY      = "Today's Engineer"}
+
+
+
+
+
+
+IEEE Online Publications 
+
+
+
+@STRING{IEEE_O_CSTO        = "{IEEE} Commun. Surveys Tuts."}
+disabled till definition is verified
+STRING{IEEE_O_DSO          = "{IEEE} Distrib. Syst. Online"}
+
+
+
+
+
+--
+EOF

tex/bare_conf.tex

@@ -0,0 +1,228 @@
+
+%% bare_conf.tex
+%% V1.4b
+%% 2015/08/26
+%% by Michael Shell
+%% See:
+%% http://www.michaelshell.org/
+%% for current contact information.
+%%
+%% This is a skeleton file demonstrating the use of IEEEtran.cls
+%% (requires IEEEtran.cls version 1.8b or later) with an IEEE
+%% conference paper.
+%%
+%% Support sites:
+%% http://www.michaelshell.org/tex/ieeetran/
+%% http://www.ctan.org/pkg/ieeetran
+%% and
+%% http://www.ieee.org/
+
+%%*************************************************************************
+%% Legal Notice:
+%% This code is offered as-is without any warranty either expressed or
+%% implied; without even the implied warranty of MERCHANTABILITY or
+%% FITNESS FOR A PARTICULAR PURPOSE! 
+%% User assumes all risk.
+%% In no event shall the IEEE or any contributor to this code be liable for
+%% any damages or losses, including, but not limited to, incidental,
+%% consequential, or any other damages, resulting from the use or misuse
+%% of any information contained here.
+%%
+%% All comments are the opinions of their respective authors and are not
+%% necessarily endorsed by the IEEE.
+%%
+%% This work is distributed under the LaTeX Project Public License (LPPL)
+%% ( http://www.latex-project.org/ ) version 1.3, and may be freely used,
+%% distributed and modified. A copy of the LPPL, version 1.3, is included
+%% in the base LaTeX documentation of all distributions of LaTeX released
+%% 2003/12/01 or later.
+%% Retain all contribution notices and credits.
+%% ** Modified files should be clearly indicated as such, including  **
+%% ** renaming them and changing author support contact information. **
+%%*************************************************************************
+
+
+% *** Authors should verify (and, if needed, correct) their LaTeX system  ***
+% *** with the testflow diagnostic prior to trusting their LaTeX platform ***
+% *** with production work. The IEEE's font choices and paper sizes can   ***
+% *** trigger bugs that do not appear when using other class files.       ***                          ***
+% The testflow support page is at:
+% http://www.michaelshell.org/tex/testflow/
+
+
+
+\documentclass[conference]{IEEEtran}
+% Some Computer Society conferences also require the compsoc mode option,
+% but others use the standard conference format.
+%
+% If IEEEtran.cls has not been installed into the LaTeX system files,
+% manually specify the path to it like:
+% \documentclass[conference]{../sty/IEEEtran}
+
+
+% needed packages
+
+\usepackage{color, colortbl}
+%\usepackage[table]{xcolor}
+\usepackage{cite}
+\usepackage{graphicx}
+\usepackage{amsfonts}
+
+\usepackage[cmex10]{amsmath}
+
+\interdisplaylinepenalty=2500
+\usepackage{algorithmic}
+\usepackage{array}
+\usepackage{mdwmath}
+\usepackage{mdwtab}
+\usepackage{eqparbox}
+
+\usepackage{epstopdf}
+%\usepackage{ulem}
+
+
+
+
+% replacement for the SI package
+\newcommand{\SI}[2]{\ensuremath{#1}\text{\,#2}}
+\newcommand{\SIrange}[3]{\ensuremath{#1} to \ensuremath{#2}\text{\,#3}}
+
+% units for the SI package
+\newcommand{\centimeter}{cm}
+\newcommand{\meter}{m}
+\newcommand{\per}{/}
+\newcommand{\milli}{m}
+\newcommand{\second}{s}
+\newcommand{\giga}{G}
+\newcommand{\hertz}{Hz}
+\newcommand{\dBm}{dBm}
+\newcommand{\percent}{\%}
+\newcommand{\decibel}{dB}
+\newcommand{\dB}{dB}
+\newcommand{\hpa}{hPa}
+\newcommand{\degree}{\ensuremath{^{\circ}}}
+
+% missing math operators
+\DeclareMathOperator*{\argmin}{arg\,min}
+\DeclareMathOperator*{\argmax}{arg\,max}
+
+
+% vector and matrix typesetting
+\renewcommand{\vec}[1]{\boldsymbol{#1}}			% italic and greek symbols
+\newcommand{\mat}[1]{\vec{#1}}					% the same as vec
+
+
+%other macros
+\newcommand{\noStep}{\overline{\text{step}}}
+
+
+% gfx include folder
+\graphicspath{ {gfx/baro/},{gfx/graph/},{gfx/paths/},{gfx/eval/},{gfx/},{gfx/grid/}}
+
+
+% correct bad hyphenation here
+\hyphenation{op-tical net-works semi-conduc-tor}
+
+
+% input stuff
+\input{misc/keywords}
+\input{misc/functions}
+
+
+\begin{document}
+%
+% paper title
+% Titles are generally capitalized except for words such as a, an, and, as,
+% at, but, by, for, in, nor, of, on, or, the, to and up, which are usually
+% not capitalized unless they are the first or last word of the title.
+% Linebreaks \\ can be used within to get better formatting as desired.
+% Do not put math or special symbols in the title.
+\title{On Prior Navigation Knowledge in Multi Sensor Indoor Localisation}
+
+
+% author names and affiliations
+% use a multiple column layout for up to three different
+% affiliations
+\author{	
+
+  \IEEEauthorblockN{Frank Ebner, Toni Fetzer and Frank Deinzer}%
+	\IEEEauthorblockA{%
+	Faculty of Computer Science and Business Information Systems\\ 
+			University of Applied Sciences W\"urzburg-Schweinfurt\\
+		W\"urzburg, Germany\\
+		\{frank.ebner, toni.fetzer, frank.deinzer\}@fhws.de\\		
+	}
+	\and
+	
+	\IEEEauthorblockN{Marcin Grzegorzek}
+	\IEEEauthorblockA{%
+		Pattern Recognition Group \\
+		University of Siegen\\
+		Siegen, Germany\\
+		\{marcin.grzegorzek\}@uni-siegen.de
+	}%
+}
+
+% conference papers do not typically use \thanks and this command
+% is locked out in conference mode. If really needed, such as for
+% the acknowledgment of grants, issue a \IEEEoverridecommandlockouts
+% after \documentclass
+
+% use for special paper notices
+%\IEEEspecialpapernotice{(Invited Paper)}
+
+
+% make the title area
+\maketitle
+
+% As a general rule, do not put math, special symbols or citations
+% in the abstract
+\input{chapters/abstract}
+
+
+% For peer review papers, you can put extra information on the cover
+% page as needed:
+% \ifCLASSOPTIONpeerreview
+% \begin{center} \bfseries EDICS Category: 3-BBND \end{center}
+% \fi
+%
+% For peerreview papers, this IEEEtran command inserts a page break and
+% creates the second title. It will be ignored for other modes.
+\IEEEpeerreviewmaketitle
+
+
+\input{chapters/introduction}
+
+\input{chapters/relatedwork}
+
+\input{chapters/system}
+
+\input{chapters/transition}
+
+\input{chapters/smoothing}
+
+\input{chapters/experiments}
+
+\input{chapters/conclusion}
+
+
+% conference papers do not normally have an appendix
+
+% use section* for acknowledgment
+%\section*{Acknowledgment}
+
+%The authors would like to thank...
+
+% balancing
+%\IEEEtriggeratref{8}
+% The "triggered" command can be changed if desired:
+%\IEEEtriggercmd{\enlargethispage{-5in}}
+
+
+% references section
+\bibliographystyle{IEEEtran}
+\bibliography{IEEEabrv,egbib}
+
+\end{document}
+
+

tex/chapters/abstract.tex

@@ -0,0 +1,4 @@
+
+\begin{abstract}
+
+\end{abstract}

tex/chapters/conclusion.tex

@@ -0,0 +1,3 @@
+\section{Conclusion}
+
+	

tex/chapters/experiments.tex

@@ -0,0 +1,3 @@
+\section{Experiments}
+
+ddd \cite{Ville09} dddd

tex/chapters/floorplan.tex

@@ -0,0 +1,4 @@
+\section{Flooplan - REMOVE}
+
+	
+		

tex/chapters/introduction.tex

@@ -0,0 +1,5 @@
+\section{Introduction}
+
+Smoothing Smoothing Smoothing
+
+

tex/chapters/relatedwork.tex

@@ -0,0 +1,6 @@
+\section{Related Work}
+
+
+
+
+

tex/chapters/smoothing.tex

@@ -0,0 +1,3 @@
+\section{Smoothing}
+
+Test 

tex/chapters/system.tex

@@ -0,0 +1,5 @@
+\section{Recursive State Estimation}
+
+
+
+

tex/chapters/transition.tex

@@ -0,0 +1,4 @@
+\section{Transition}
+\label{sec:transition}
+
+		%

tex/make.sh

@@ -0,0 +1,12 @@
+PATH=$PATH:/mnt/data/texlive/bin/x86_64-linux/
+
+latex bare_conf.tex
+bibtex bare_conf
+latex bare_conf.tex
+latex bare_conf.tex
+
+dvips bare_conf.dvi
+
+ps2pdf14 bare_conf.ps
+
+atril bare_conf.pdf&

tex/misc/functions.tex

@@ -0,0 +1,137 @@
+
+\newcommand{\mAvgSquaredError}{\ensuremath{\overline{e}}}
+
+\newcommand{\mLogDistGamma}{\ensuremath{\gamma}}
+\newcommand{\mLogDistTX}{TX}
+
+\newcommand{\mDongle}[1]{\ensuremath{D_{#1}}}
+%\newcommand{\mDongle}{d}								% dongle
+\newcommand{\mBeacon}[1]{\ensuremath{B_{#1}}}			% beacon
+
+\newcommand{\mRssi}{\ensuremath{s}}						% client's signal-strength measurement
+\newcommand{\mMdlRSSI}{\ensuremath{\varsigma}}			% model's signal-strength
+
+\newcommand{\mPosAP}{\varrho}							% char for access point position vector
+\newcommand{\mPos}{\rho}								% char for positions
+
+
+\newcommand{\mPosVec}{\vec{\mPos}}						% position vector
+\newcommand{\mRssiVec}{\vec{s}}							% client signal strength measurements
+
+\newcommand{\mState}{q}									% state variable
+\newcommand{\mStateVec}{\vec{q}}						% state vector variable
+\newcommand{\mObs}{o}									% observation variable
+\newcommand{\mObsVec}{\vec{o}}							% observation vector variable
+\newcommand{\mObsWifi}{\vec{o}_{\text{wifi}}}			% wifi observation
+
+\newcommand{\mProb}{p}									% char for probability
+
+\newcommand{\mMovingAvgWithSize}[1]{\ensuremath{\text{avg}_{#1}}}
+
+\newcommand{\mPressure}{\rho}
+\newcommand{\mObsPressure}{\mPressure_\text{rel}}				% symbol for observation pressure
+\newcommand{\mStatePressure}{\hat{\mPressure}_\text{rel}}		% symbol for state pressure
+
+\newcommand{\mHeading}{\theta}
+\newcommand{\mObsHeading}{\Delta\mHeading}						% symbol used for the observation heading
+\newcommand{\mStateHeading}{\mHeading}							% symbol used for the state heading
+
+\newcommand{\mSteps}{n_\text{steps}}
+\newcommand{\mObsSteps}{\mSteps}
+
+\newcommand{\mNN}{\text{nn}}
+\newcommand{\mKNN}{\text{knn}}
+\newcommand{\fPos}[1]{\textbf{pos}(#1)}
+\newcommand{\fDistance}[2]{\delta(#1, #2)}
+\newcommand{\fWA}[1]{\text{wall}(#1)}
+\newcommand{\fDD}[1]{\text{door}(#1)}
+\newcommand{\fImp}[1]{\text{imp}(#1)}
+\newcommand{\fNN}[2]{\text{nn}(#1, #2)}
+\newcommand{\fLength}[2]{\text{d}(#1, #2)}
+
+%\newcommand{\mTarget}{\dot{v}}
+\newcommand{\mVertexA}{v_i}
+\newcommand{\mVertexB}{v_j}
+\newcommand{\mEdgeAB}{e_{i,j}}
+\newcommand{\mVertexDest}{v_\text{dest}}
+
+\newcommand{\mUsePath}{\kappa}
+
+\newcommand{\mStepSize}{s_\text{step}}
+
+%\newcommand{\docIBeacon}{iBeacon}
+
+% for equation references
+\newcommand{\refeq}[1]{eq. \eqref{#1}}
+
+% add todo notes
+\newcommand{\todo}[1]{%
+	\noindent%
+	\fcolorbox{black}{yellow}{%
+		\parbox[position]{0.45\textwidth}{%
+			\footnotesize%
+			{\bf TODO} #1%
+		}%
+	}%
+}
+
+%\newcommand{\commentByFrank}[1]{}
+%\newcommand{\commentByToni}[1]{}
+
+%comments
+\newcommand{\commentByFrank}[1]{%
+	\noindent%
+	\fcolorbox{black}{cyan}{%
+		\parbox[position]{0.45\textwidth}{%
+			\footnotesize%
+			{\bf Frank:} #1%
+		}%
+	}%
+}
+\newcommand{\commentByLukas}[1]{%
+	\noindent%
+	\fcolorbox{black}{green}{%
+		\parbox[position]{0.45\textwidth}{%
+			\footnotesize%
+			{\bf Lukas:} #1%
+		}%
+	}%
+}
+\newcommand{\commentByToni}[1]{%
+	\noindent%
+	\fcolorbox{black}{red}{%
+		\parbox[position]{0.45\textwidth}{%
+			\footnotesize%
+			{\bf Toni:} #1%
+		}%
+	}%
+}
+
+\newcommand{\docRSSI}{RSSI}
+\newcommand{\docTX}{TX}
+\newcommand{\docLogDist}{log-distance}
+
+%\newcommand{\docAP}{access-point}
+%\newcommand{\docAPs}{access-points}
+
+
+
+
+\newcommand{\R}{\mathbb{R}}
+\newcommand{\N}{\mathbb{N}}
+
+\newcommand{\mPLE}{\ensuremath{\gamma}}					% path-loss exponent
+\newcommand{\mTXP}{\ensuremath{P_0}}					% tx-power
+\newcommand{\mWAF}{\ensuremath{\beta}}					% wall attenuation factor
+
+\newcommand{\mMdlDist}{\ensuremath{d}}					% distance used within propagation models
+
+%\newcommand{\mGraph}{\ensuremath{G}}
+%\newcommand{\mVertices}{\ensuremath{V}}
+%\newcommand{\mVertex}{\ensuremath{v}}
+%\newcommand{\mVertexB}{\ensuremath{w}}
+%\newcommand{\mEdges}{\ensuremath{E}}
+%\newcommand{\mEdge}{\ensuremath{e}}
+
+
+

tex/misc/keywords.tex

@@ -0,0 +1,31 @@
+% keyword macros
+\newcommand{\docIBeacon}{iBeacon}
+
+% wifi naming
+\newcommand{\wifiRSSI}{RSSI}
+\newcommand{\wifiTxPower}{TX-Power}
+\newcommand{\wifiPathLossExp}{PathLoss}
+
+\newcommand{\wifiPropLogScale}{Log-Scale}
+\newcommand{\wifiPropLogScaleWalls}{Log-Scale-Walls}
+\newcommand{\docLogDistance}{log-distance}
+\newcommand{\docLogDistanceWalls}{wall-attenuation-factor}
+
+
+% misc
+\newcommand{\docTxPower}{TX-Power}
+\newcommand{\docPathLossExp}{PathLoss}
+\newcommand{\docPathLoss}{Pathloss}
+
+\newcommand{\docsAP}{AP}
+\newcommand{\docAPshort}{AP}
+\newcommand{\docAP}{access-point}
+\newcommand{\docAPs}{access-points}
+
+\newcommand{\docWIFI}{Wi\hbox{-}Fi}
+\newcommand{\docBeacon}{\Gls{Beacon}}
+\newcommand{\docBeacons}{\Glspl{Beacon}}
+
+\newcommand{\docsRSSI}{RSSI}
+
+\newcommand{\docDSimplex}{downhill-simplex}