429 lines
14 KiB
C++
429 lines
14 KiB
C++
#include "mainFtm.h"
|
|
|
|
#include "mesh.h"
|
|
#include "filter.h"
|
|
#include "Settings.h"
|
|
//#include "meshPlotter.h"
|
|
#include "Plotty.h"
|
|
|
|
#include <memory>
|
|
#include <thread>
|
|
#include <filesystem>
|
|
#include <chrono>
|
|
|
|
#include <Indoor/floorplan/v2/FloorplanReader.h>
|
|
#include <Indoor/sensors/offline/FileReader.h>
|
|
#include <Indoor/geo/Heading.h>
|
|
#include <Indoor/geo/Point2.h>
|
|
#include <Indoor/sensors/imu/TurnDetection.h>
|
|
#include <Indoor/sensors/imu/StepDetection.h>
|
|
#include <Indoor/sensors/imu/PoseDetection.h>
|
|
#include <Indoor/sensors/imu/MotionDetection.h>
|
|
#include <Indoor/sensors/pressure/RelativePressure.h>
|
|
#include <Indoor/data/Timestamp.h>
|
|
|
|
|
|
#include <Indoor/math/stats/Statistics.h>
|
|
|
|
#include "FtmKalman.h"
|
|
|
|
#include <sys/stat.h>
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
std::vector<std::tuple<float, float, float>> getFtmValues(Offline::FileReader& fr, Interpolator<uint64_t, Point3>& gtInterpolator, const MACAddress nuc)
|
|
{
|
|
std::vector<std::tuple<float, float, float>> result;
|
|
|
|
for (const Offline::Entry& e : fr.getEntries())
|
|
{
|
|
if (e.type == Offline::Sensor::WIFI_FTM)
|
|
{
|
|
const Timestamp ts = Timestamp::fromMS(e.ts);
|
|
|
|
Point3 gtPos = gtInterpolator.get(static_cast<uint64_t>(ts.ms())) + Point3(0, 0, 1.3);
|
|
|
|
auto wifi = fr.getWifiFtm()[e.idx].data;
|
|
|
|
if (wifi.getAP().getMAC() == nuc)
|
|
{
|
|
Point3 apPos = Settings::data.Path0.APs.find(wifi.getAP().getMAC())->second;
|
|
float apDist = gtPos.getDistance(apPos);
|
|
float ftmDist = wifi.getFtmDist();
|
|
float rssi = wifi.getRSSI();
|
|
|
|
result.push_back({ apDist, ftmDist, rssi });
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::pair<float, float> optimizeFtm(std::vector<std::tuple<float, float, float>>& values)
|
|
{
|
|
std::vector<std::pair<float, float>> error;
|
|
|
|
for (float offset = 0; offset < 10.0f; offset += 0.25)
|
|
{
|
|
Stats::Statistics<float> diffs;
|
|
|
|
for (const auto& data : values)
|
|
{
|
|
float apDist = std::get<0>(data);
|
|
float ftmDist = std::get<1>(data);
|
|
ftmDist += offset;
|
|
|
|
float diff = (apDist - ftmDist);
|
|
|
|
diffs.add(diff);
|
|
}
|
|
|
|
error.push_back({ offset, diffs.getSquaredSumAvg() });
|
|
}
|
|
|
|
auto minElement = std::min_element(error.begin(), error.end(), [](std::pair<float, float> a, std::pair<float, float> b) {
|
|
return a.second < b.second;
|
|
});
|
|
|
|
std::cout << "Min ftm offset \t" << minElement->first << "\t" << minElement->second << "\n";
|
|
|
|
return *minElement;
|
|
}
|
|
|
|
std::pair<float, float> optimizeRssi(std::vector<std::tuple<float, float, float>>& values)
|
|
{
|
|
std::vector<std::pair<float, float>> error;
|
|
|
|
for (float pathLoss = 2.0f; pathLoss < 4.0f; pathLoss += 0.125)
|
|
{
|
|
Stats::Statistics<float> diffs;
|
|
|
|
for (const auto& data : values)
|
|
{
|
|
float apDist = std::get<0>(data);
|
|
float rssi = std::get<2>(data);
|
|
float rssiDist = LogDistanceModel::rssiToDistance(-40, pathLoss, rssi);
|
|
|
|
float diff = (apDist - rssiDist);
|
|
|
|
diffs.add(diff);
|
|
}
|
|
|
|
error.push_back({ pathLoss, diffs.getSquaredSumAvg() });
|
|
}
|
|
|
|
auto minElement = std::min_element(error.begin(), error.end(), [](std::pair<float, float> a, std::pair<float, float> b) {
|
|
return a.second < b.second;
|
|
});
|
|
|
|
std::cout << "Min path loss \t" << minElement->first << "\t" << minElement->second << "\n";
|
|
|
|
return *minElement;
|
|
}
|
|
|
|
void optimize(Offline::FileReader& fr, Interpolator<uint64_t, Point3>& gtInterpolator)
|
|
{
|
|
int i = 1;
|
|
for (auto nuc : {Settings::NUC1, Settings::NUC2, Settings::NUC3, Settings::NUC4})
|
|
{
|
|
auto values = getFtmValues(fr, gtInterpolator, nuc);
|
|
std::cout << "NUC" << i++ << "\n";
|
|
|
|
optimizeFtm(values);
|
|
optimizeRssi(values);
|
|
}
|
|
}
|
|
|
|
void exportFtmValues(Offline::FileReader& fr, Interpolator<uint64_t, Point3>& gtInterpolator)
|
|
{
|
|
std::fstream fs;
|
|
fs.open("test.txt", std::fstream::out);
|
|
|
|
fs << "timestamp;nucid;dist;rssiDist;ftmDist;ftmStdDev" << "\n";
|
|
|
|
for (const Offline::Entry& e : fr.getEntries())
|
|
{
|
|
if (e.type == Offline::Sensor::WIFI_FTM)
|
|
{
|
|
const Timestamp ts = Timestamp::fromMS(e.ts);
|
|
|
|
Point3 gtPos = gtInterpolator.get(static_cast<uint64_t>(ts.ms())) + Point3(0, 0, 1.3);
|
|
|
|
auto wifi = fr.getWifiFtm()[e.idx].data;
|
|
|
|
int nucid = Settings::NUCS.at(wifi.getAP().getMAC()).ID;
|
|
float ftm_offset = Settings::NUCS.at(wifi.getAP().getMAC()).ftm_offset;
|
|
float rssi_pathloss = Settings::NUCS.at(wifi.getAP().getMAC()).rssi_pathloss;
|
|
|
|
float rssiDist = LogDistanceModel::rssiToDistance(-40, rssi_pathloss, wifi.getRSSI());
|
|
float ftmDist = wifi.getFtmDist() + ftm_offset; //in m; plus static offset
|
|
float ftmStdDev = wifi.getFtmDistStd();
|
|
|
|
Point3 apPos = Settings::data.Path0.APs.find(wifi.getAP().getMAC())->second;
|
|
float apDist = gtPos.getDistance(apPos);
|
|
|
|
fs << ts.ms() << ";" << nucid << ";" << apDist << ";" << rssiDist << ";" << ftmDist << ";" << ftmStdDev << "\n";
|
|
}
|
|
|
|
}
|
|
fs.close();
|
|
|
|
}
|
|
|
|
static Stats::Statistics<float> run(Settings::DataSetup setup, int numFile, std::string folder) {
|
|
|
|
// reading file
|
|
std::string currDir = std::filesystem::current_path().string();
|
|
|
|
Floorplan::IndoorMap* map = Floorplan::Reader::readFromFile(setup.map);
|
|
Offline::FileReader fr(setup.training[numFile]);
|
|
|
|
// ground truth
|
|
std::vector<int> gtPath;
|
|
for(int i = 0; i < setup.numGTPoints; ++i){gtPath.push_back(i);}
|
|
Interpolator<uint64_t, Point3> gtInterpolator = fr.getGroundTruthPath(map, gtPath);
|
|
Stats::Statistics<float> errorStats;
|
|
|
|
//calculate distance of path
|
|
std::vector<Interpolator<uint64_t, Point3>::InterpolatorEntry> gtEntries = gtInterpolator.getEntries();
|
|
double distance = 0;
|
|
for(int i = 1; i < gtEntries.size(); ++i){
|
|
distance += gtEntries[i].value.getDistance(gtEntries[i-1].value);
|
|
}
|
|
|
|
std::cout << "Distance of Path: " << distance << std::endl;
|
|
|
|
// error file
|
|
const long int t = static_cast<long int>(time(NULL));
|
|
auto evalDir = std::experimental::filesystem::path(Settings::errorDir);
|
|
evalDir.append(folder);
|
|
|
|
if (!std::experimental::filesystem::exists(evalDir)) {
|
|
std::experimental::filesystem::create_directory(evalDir);
|
|
}
|
|
|
|
std::ofstream errorFile;
|
|
errorFile.open (evalDir.string() + "/" + std::to_string(numFile) + "_" + std::to_string(t) + ".csv");
|
|
|
|
|
|
// wifi
|
|
auto kalmanMap = std::make_shared<std::unordered_map<MACAddress, Kalman>>();
|
|
kalmanMap->insert({ Settings::NUC1, Kalman(1, 6.156) });
|
|
kalmanMap->insert({ Settings::NUC2, Kalman(2, 5.650) });
|
|
kalmanMap->insert({ Settings::NUC3, Kalman(3, 6.107) });
|
|
kalmanMap->insert({ Settings::NUC4, Kalman(4, 3.985) });
|
|
|
|
// mesh
|
|
NM::NavMeshSettings set;
|
|
MyNavMesh mesh;
|
|
MyNavMeshFactory fac(&mesh, set);
|
|
fac.build(map);
|
|
|
|
const Point3 srcPath0(9.8, 24.9, 0); // fixed start pos
|
|
|
|
// add shortest-path to destination
|
|
//const Point3 dst(51, 45, 1.7);
|
|
//const Point3 dst(25, 45, 0);
|
|
//NM::NavMeshDijkstra::stamp<MyNavMeshTriangle>(mesh, dst);
|
|
|
|
// debug show
|
|
//MeshPlotter dbg;
|
|
//dbg.addFloors(map);
|
|
//dbg.addOutline(map);
|
|
//dbg.addMesh(mesh);
|
|
////dbg.addDijkstra(mesh);
|
|
//dbg.draw();
|
|
|
|
Plotty plot(map);
|
|
plot.buildFloorplan();
|
|
plot.setGroundTruth(gtPath);
|
|
plot.plot();
|
|
|
|
// particle-filter
|
|
const int numParticles = 5000;
|
|
//auto init = std::make_unique<MyPFInitFixed>(&mesh, srcPath0); // known position
|
|
auto init = std::make_unique<MyPFInitUniform>(&mesh); // uniform distribution
|
|
auto eval = std::make_unique<MyPFEval>();
|
|
eval->assignProps = true;
|
|
eval->kalmanMap = kalmanMap;
|
|
|
|
//auto trans = std::make_unique<MyPFTrans>(mesh);
|
|
auto trans = std::make_unique<MyPFTransStatic>();
|
|
|
|
auto resample = std::make_unique<SMC::ParticleFilterResamplingSimple<MyState>>();
|
|
auto estimate = std::make_unique<SMC::ParticleFilterEstimationWeightedAverage<MyState>>();
|
|
|
|
// setup
|
|
MyFilter pf(numParticles, std::move(init));
|
|
pf.setEvaluation(std::move(eval));
|
|
pf.setTransition(std::move(trans));
|
|
pf.setResampling(std::move(resample));
|
|
pf.setEstimation(std::move(estimate));
|
|
//pf.setNEffThreshold(0.85);
|
|
pf.setNEffThreshold(0.0);
|
|
|
|
// sensors
|
|
MyControl ctrl;
|
|
MyObservation obs;
|
|
|
|
StepDetection sd;
|
|
PoseDetection pd;
|
|
TurnDetection td(&pd);
|
|
RelativePressure relBaro;
|
|
ActivityDetector act;
|
|
relBaro.setCalibrationTimeframe( Timestamp::fromMS(5000) );
|
|
Timestamp lastTimestamp = Timestamp::fromMS(0);
|
|
|
|
//optimize(fr, gtInterpolator);
|
|
//return errorStats;
|
|
|
|
int i = 0;
|
|
//exportFtmValues(fr, gtInterpolator);
|
|
|
|
|
|
// parse each sensor-value within the offline data
|
|
for (const Offline::Entry& e : fr.getEntries()) {
|
|
|
|
const Timestamp ts = Timestamp::fromMS(e.ts);
|
|
|
|
if (e.type == Offline::Sensor::WIFI_FTM) {
|
|
auto ftm = fr.getWifiFtm()[e.idx].data;
|
|
|
|
float ftm_offset = Settings::NUCS.at(ftm.getAP().getMAC()).ftm_offset;
|
|
float ftmDist = ftm.getFtmDist() + ftm_offset; // in m; plus static offset
|
|
|
|
auto& kalman = kalmanMap->at(ftm.getAP().getMAC());
|
|
float predictDist = kalman.predict(ts, ftmDist);
|
|
|
|
//ftm.setFtmDist(predictDist);
|
|
|
|
obs.wifi.insert_or_assign(ftm.getAP().getMAC(), ftm);
|
|
}
|
|
|
|
//if (ctrl.numStepsSinceLastEval > 0)
|
|
//if (ts - lastTimestamp >= Timestamp::fromMS(500))
|
|
if (obs.wifi.size() == 4)
|
|
{
|
|
|
|
obs.currentTime = ts;
|
|
ctrl.currentTime = ts;
|
|
|
|
// if(ctrl.numStepsSinceLastEval > 0){
|
|
// pf.updateTransitionOnly(&ctrl);
|
|
// }
|
|
MyState est = pf.update(&ctrl, obs); //pf.updateEvaluationOnly(obs);
|
|
ctrl.afterEval();
|
|
Point3 gtPos = gtInterpolator.get(static_cast<uint64_t>(ts.ms())) + Point3(0,0,0.1);
|
|
lastTimestamp = ts;
|
|
|
|
ctrl.lastEstimate = est.pos.pos;
|
|
|
|
|
|
// draw wifi ranges
|
|
for (auto& ftm : obs.wifi)
|
|
{
|
|
int nucid = Settings::NUCS.at(ftm.second.getAP().getMAC()).ID;
|
|
|
|
if (nucid == 1)
|
|
{
|
|
Point3 apPos = Settings::data.Path0.APs.find(ftm.first)->second;
|
|
// plot.addCircle(nucid, apPos.xy(), ftm.second.getFtmDist());
|
|
}
|
|
}
|
|
|
|
obs.wifi.clear();
|
|
|
|
//plot
|
|
//dbg.showParticles(pf.getParticles());
|
|
//dbg.setCurPos(est.pos.pos);
|
|
//dbg.setGT(gtPos);
|
|
//dbg.addEstimationNode(est.pos.pos);
|
|
//dbg.addGroundTruthNode(gtPos);
|
|
//dbg.setTimeInMinute(static_cast<int>(ts.sec()) / 60, static_cast<int>(static_cast<int>(ts.sec())%60));
|
|
//dbg.draw();
|
|
|
|
plot.showParticles(pf.getParticles());
|
|
plot.setCurEst(est.pos.pos);
|
|
plot.setGroundTruth(gtPos);
|
|
|
|
plot.addEstimationNode(est.pos.pos);
|
|
plot.setActivity((int) act.get());
|
|
plot.splot.getView().setCamera(0, 0);
|
|
plot.splot.getView().setEqualXY(true);
|
|
|
|
plot.plot();
|
|
|
|
|
|
//std::this_thread::sleep_for(500ms);
|
|
|
|
// error calc
|
|
// float err_m = gtPos.getDistance(est.pos.pos);
|
|
// errorStats.add(err_m);
|
|
// errorFile << ts.ms() << " " << err_m << "\n";
|
|
|
|
//error calc with penalty for wrong floor
|
|
double errorFactor = 3.0;
|
|
Point3 gtPosError = Point3(gtPos.x, gtPos.y, errorFactor * gtPos.z);
|
|
Point3 estError = Point3(est.pos.pos.x, est.pos.pos.y, errorFactor * est.pos.pos.z);
|
|
float err_m = gtPosError.getDistance(estError);
|
|
errorStats.add(err_m);
|
|
errorFile << ts.ms() << " " << err_m << "\n";
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// get someting on console
|
|
std::cout << "Statistical Analysis Filtering: " << std::endl;
|
|
std::cout << "Median: " << errorStats.getMedian() << " Average: " << errorStats.getAvg() << " Std: " << errorStats.getStdDev() << std::endl;
|
|
|
|
// save the statistical data in file
|
|
errorFile << "========================================================== \n";
|
|
errorFile << "Average of all statistical data: \n";
|
|
errorFile << "Median: " << errorStats.getMedian() << "\n";
|
|
errorFile << "Average: " << errorStats.getAvg() << "\n";
|
|
errorFile << "Standard Deviation: " << errorStats.getStdDev() << "\n";
|
|
errorFile << "75 Quantil: " << errorStats.getQuantile(0.75) << "\n";
|
|
errorFile.close();
|
|
|
|
return errorStats;
|
|
}
|
|
|
|
int mainFtm(int argc, char** argv) {
|
|
|
|
Stats::Statistics<float> statsAVG;
|
|
Stats::Statistics<float> statsMedian;
|
|
Stats::Statistics<float> statsSTD;
|
|
Stats::Statistics<float> statsQuantil;
|
|
Stats::Statistics<float> tmp;
|
|
|
|
std::string evaluationName = "prologic/tmp";
|
|
|
|
for(int i = 0; i < 1; ++i){
|
|
for(int j = 0; j < 1; ++j){
|
|
tmp = run(Settings::data.Path0, j, evaluationName);
|
|
statsMedian.add(tmp.getMedian());
|
|
statsAVG.add(tmp.getAvg());
|
|
statsSTD.add(tmp.getStdDev());
|
|
statsQuantil.add(tmp.getQuantile(0.75));
|
|
}
|
|
|
|
std::cout << "Iteration " << i << " completed" << std::endl;
|
|
}
|
|
|
|
std::cout << "==========================================================" << std::endl;
|
|
std::cout << "Average of all statistical data: " << std::endl;
|
|
std::cout << "Median: " << statsMedian.getAvg() << std::endl;
|
|
std::cout << "Average: " << statsAVG.getAvg() << std::endl;
|
|
std::cout << "Standard Deviation: " << statsSTD.getAvg() << std::endl;
|
|
std::cout << "75 Quantil: " << statsQuantil.getAvg() << std::endl;
|
|
std::cout << "==========================================================" << std::endl;
|
|
|
|
|
|
//std::this_thread::sleep_for(std::chrono::seconds(60));
|
|
|
|
|
|
return 0;
|
|
}
|