interface changes

added new data-strcutures for new sensors
new helper methods
fixed some issues

sensors/radio/AccessPoint.h

@@ -45,6 +45,11 @@ public:
 		;
 	}
 
+	/** equals? */
+	bool operator == (const AccessPoint& o) {
+		return (o.mac == mac) && (o.ssid == ssid);
+	}
+
 public:
 
 	/** get the AP's MAC address */

sensors/radio/VAPGrouper.h

@@ -50,18 +50,27 @@ private:
 	/** the signal-strength aggregation algorithm to use */
 	const Aggregation agg;
 
+	/** respect only outputs with at-least X occurences of one physical hardware [can be used to prevent issues] */
+	int minOccurences;
+
 public:
 
 	/** ctor */
-	VAPGrouper(const Mode mode, const Aggregation agg) : mode(mode), agg(agg) {
-
+	VAPGrouper(const Mode mode, const Aggregation agg, const int minOccurences = 2) :
+		mode(mode), agg(agg), minOccurences(minOccurences) {
+		;
 	}
 
+	/** set the number of needed occurences per VAP-group to be accepted */
+	void setMinOccurences(const int min) {
+		this->minOccurences = min;
+	}
 
 	/** get a vap-grouped version of the given input */
 	WiFiMeasurements group(const WiFiMeasurements& original) const {
 
 		// first, group all VAPs into a vector [one vector per VAP-group]
+		// by using the modified MAC address that all VAPs have in common
 		std::unordered_map<MACAddress, std::vector<WiFiMeasurement>> grouped;
 
 		for (const WiFiMeasurement& m : original.entries) {
@@ -72,8 +81,9 @@ public:
 
 		}
 
-		// output
+		// to-be-constructed output
 		WiFiMeasurements result;
+		int skipped = 0;
 
 		// perform aggregation on each VAP-group
 		for (auto it : grouped) {
@@ -81,6 +91,9 @@ public:
 			const MACAddress& base = it.first;
 			const std::vector<WiFiMeasurement>& vaps = it.second;
 
+			// remove entries that do not satify the min-occurences metric
+			if ((int)vaps.size() < minOccurences) {++skipped; continue;}
+
 			// group all VAPs into one measurement
 			const WiFiMeasurement groupedMeasurement = groupVAPs(base, vaps);
 
@@ -89,7 +102,12 @@ public:
 
 		}
 
-		Log::add(name, "grouped " + std::to_string(original.entries.size()) + " measurements into " + std::to_string(result.entries.size()), true);
+		// debug
+		Log::add(name,
+				 "grouped " + std::to_string(original.entries.size()) + " measurements " +
+				 "into " + std::to_string(result.entries.size()) + " [omitted: " + std::to_string(skipped) + "]",
+				true
+		);
 
 
 		// done

sensors/radio/WiFiMeasurements.h

@@ -23,8 +23,8 @@ struct WiFiMeasurements {
 	}
 
 	/** get the measurements for the given MAC [if available] otherwise null */
-	WiFiMeasurement* getForMac(const MACAddress& mac) {
-		for (WiFiMeasurement& m : entries) {
+	const WiFiMeasurement* getForMac(const MACAddress& mac) const {
+		for (const WiFiMeasurement& m : entries) {
 			if (m.getAP().getMAC() == mac) {
 				return &m;
 			}
@@ -32,6 +32,46 @@ struct WiFiMeasurements {
 		return nullptr;
 	}
 
+	/** remove the entry for the given MAC (if any) */
+	void remove(const MACAddress& mac) {
+		for (size_t i = 0; i < entries.size(); ++i) {
+			if (entries[i].getAP().getMAC() == mac) {
+				entries.erase(entries.begin() + i);
+				break;
+			}
+		}
+	}
+
+
+	/** create a combination */
+	static WiFiMeasurements mix(const WiFiMeasurements& a, const WiFiMeasurements& b, float sec = 3) {
+
+		Timestamp max;
+		WiFiMeasurements res;
+
+		for (const WiFiMeasurement& m : a.entries) {
+			res.entries.push_back(m);
+			if (m.getTimestamp() > max) {max = m.getTimestamp();}
+		}
+
+		for (const WiFiMeasurement& m : b.entries) {
+			res.entries.push_back(m);
+			if (m.getTimestamp() > max) {max = m.getTimestamp();}
+		}
+
+		std::vector<WiFiMeasurement> tmp;
+		std::swap(res.entries, tmp);
+
+		for (const WiFiMeasurement& m : tmp) {
+			if ((max - m.getTimestamp()).sec() < sec) {
+				res.entries.push_back(m);
+			}
+		}
+
+		return res;
+
+	}
+
 };
 
 #endif // WIFIMEASUREMENTS_H

sensors/radio/WiFiProbabilityFree.h

@@ -27,15 +27,25 @@ private:
 	/** the map's floorplan */
 	Floorplan::IndoorMap* map;
 
+	std::vector<AccessPoint> allAPs;
+
+	bool useError = false;
+
 public:
 
 	WiFiObserverFree(const float sigma, WiFiModel& model) : sigma(sigma), model(model) {
+		allAPs = model.getAllAPs();
+	}
 
+	void setUseError(const bool useError) {
+		this->useError = useError;
 	}
 
 	double getProbability(const Point3& pos_m, const Timestamp curTime, const WiFiMeasurements& obs) const {
 
 		double prob = 1.0;
+		//double prob = 0;
+
 		int numMatchingAPs = 0;
 
 		// process each measured AP
@@ -50,7 +60,6 @@ public:
 			// NaN? -> AP not known to the model -> skip
 			if (modelRSSI != modelRSSI) {continue;}
 
-
 			// the scan's RSSI
 			const float scanRSSI = entry.getRSSI();
 
@@ -60,24 +69,81 @@ public:
 			Assert::isTrue(age.ms() >= 0, "found a negative wifi measurement age. this does not make sense");
 			Assert::isTrue(age.ms() <= 60000, "found a 60 second old wifi measurement. maybe there is a coding error?");
 
+			Assert::isBetween(scanRSSI, -100.0f, -30.0f, "scan-rssi out of range");
+			//Assert::isBetween(modelRSSI, -160.0f, -10.0f, "model-rssi out of range");
+
 			// sigma grows with measurement age
 			const float sigma = this->sigma + this->sigmaPerSecond * age.sec();
 
+			// probability for this AP
+			double local = Distribution::Normal<double>::getProbability(modelRSSI, sigma, scanRSSI);
+			//double local = Distribution::Exponential<double>::getProbability(0.1, std::abs(modelRSSI-scanRSSI));
+
+			// also add the error value? [location is OK but model is wrong]
+			if (useError) {
+				local = 0.95 * local + 0.05 * (1.0-local);
+				//local = 0.95 * local + 0.05;
+#warning "TODO"
+			}
+
 			// update probability
-			prob *= Distribution::Normal<double>::getProbability(modelRSSI, sigma, scanRSSI);
-			//prob *= Distribution::Region<double>::getProbability(modelRSSI, sigma, scanRSSI);
+			prob *= local;
 
 			++numMatchingAPs;
 
 		}
 
 		// sanity check
-        //Assert::isTrue(numMatchingAPs > 0, "not a single measured AP was matched against known ones. coding error? model error?");
+		//Assert::isTrue(numMatchingAPs > 0, "not a single measured AP was matched against known ones. coding error? model error?");
 
 		return prob;
 
 	}
 
+	/**
+	 * for some locations it might make sense to also look at APs
+	 * that have NOT been discovered by the smartphone but SHOULD
+	 * be very well receivable at a location.
+	 * such locations can be opted-out by using this veto-probability
+	 */
+	double getVeto(const Point3& pos_m, const Timestamp curTime, const WiFiMeasurements& obs) const {
+
+		(void) curTime;
+
+		struct APR {
+			AccessPoint ap;
+			float rssi;
+			APR(const AccessPoint& ap, const float rssi) : ap(ap), rssi(rssi) {;}
+		};
+
+		std::vector<APR> all;
+		for (const AccessPoint& ap : allAPs) {
+			const float rssi = model.getRSSI(ap.getMAC(), pos_m);
+			if (rssi != rssi) {continue;}	// unknown to the model
+			all.push_back(APR(ap, rssi));
+		}
+
+		// stort by RSSI
+		auto comp = [&] (const APR& apr1, const APR& apr2) {return apr1.rssi > apr2.rssi;};
+		std::sort(all.begin(), all.end(), comp);
+
+		int numVetos = 0;
+
+		for (int i = 0; i < 3; ++i) {
+			const APR& apr = all[i];
+			const WiFiMeasurement* mes = obs.getForMac(apr.ap.getMAC());
+			const float rssiScan = (mes) ? (mes->getRSSI()) : (-100);
+			const float rssiModel = apr.rssi;
+			const float diff = std::abs(rssiScan - rssiModel);
+			if (diff > 20) {++numVetos;}
+		}
+
+		if (numVetos == 0)	{return 0.70;}
+		if (numVetos == 1)	{return 0.29;}
+		else				{return 0.01;}
+
+	}
+
 	template <typename Node> double getProbability(const Node& n, const Timestamp curTime, const WiFiMeasurements& obs, const int age_ms = 0) const {
 
         return this->getProbability(n.inMeter() + Point3(0,0,1.3), curTime, obs);

sensors/radio/WiFiQualityAnalyzer.h

@@ -68,8 +68,8 @@ private:
 		const float stdDev = std::sqrt(avg2 - avg*avg);
 
 		// avg rssi score
-		const float minRSSI = -90;
-		const float maxRSSI = -65;
+		const float minRSSI = -85;
+		const float maxRSSI = -70;
 		float score1 = (avg-minRSSI) / (maxRSSI-minRSSI);	// min = 0; max = 1
 		if (score1 > 1) {score1 = 1;}
 		if (score1 < 0) {score1 = 0;}

sensors/radio/model/WiFiModel.h

@@ -3,6 +3,11 @@
 
 #include "../AccessPoint.h"
 #include "../../../geo/Point3.h"
+#include <vector>
+
+
+#include "../../../data/XMLserialize.h"
+
 
 /**
  * interface for signal-strength prediction models.
@@ -10,7 +15,7 @@
  * the model is passed a MAC-address of an AP in question, and a position.
  * hereafter the model returns the RSSI for this AP at the questioned location.
  */
-class WiFiModel {
+class WiFiModel : public XMLserialize {
 
 public:
 
@@ -31,6 +36,7 @@ public:
 	 */
 	virtual float getRSSI(const MACAddress& accessPoint, const Point3 position_m) const = 0;
 
+
 };
 
 #endif // WIFIMODEL_H

sensors/radio/model/WiFiModelLogDist.h

@@ -77,6 +77,14 @@ public:
 
 	}
 
+	void readFromXML(XMLDoc* doc, XMLElem* src) override {
+		throw Exception("not yet implemented");
+	}
+
+	void writeToXML(XMLDoc* doc, XMLElem* dst) override {
+		throw Exception("not yet implemented");
+	}
+
 };
 
 #endif // WIFIMODELLOGDIST_H

sensors/radio/model/WiFiModelLogDistCeiling.h

@@ -10,6 +10,8 @@
 #include "../VAPGrouper.h"
 #include "../../../misc/Debug.h"
 
+#include "../../../data/XMLserialize.h"
+
 /**
  * signal-strength estimation using log-distance model
  * including ceilings between AP and position
@@ -52,6 +54,13 @@ public:
 
 	}
 
+	/** get the entry for the given mac. exception if missing */
+	const APEntry& getAP(const MACAddress& mac) const {
+		const auto& it = accessPoints.find(mac);
+		if (it == accessPoints.end()) {throw Exception("model does not contain an entry for " + mac.asString());}
+		return it->second;
+	}
+
 	/** get a list of all APs known to the model */
 	std::vector<AccessPoint> getAllAPs() const {
 		std::vector<AccessPoint> aps;
@@ -109,6 +118,14 @@ public:
 
 	}
 
+	/**
+	 * make the given AP (and its parameters) known to the model
+	 * usually txp,exp,waf are checked for a sane range. if you know what you are doing, set assertSafe to false!
+	 */
+	void addAP(const MACAddress& accessPoint, const Point3 pos_m, const float txp, const float exp, const float waf, const bool assertSafe = true) {
+		addAP(accessPoint, APEntry(pos_m, txp, exp, waf), assertSafe);
+	}
+
 	/** remove all added APs */
 	void clear() {
 		accessPoints.clear();
@@ -130,7 +147,9 @@ public:
 		const float rssiLOS = LogDistanceModel::distanceToRssi(params.txp, params.exp, distance_m);
 
 		// WAF loss (params.waf is a negative value!) -> WAF loss is also a negative value
-		const float wafLoss = params.waf * ceilings.numCeilingsBetween(position_m, params.position_m);
+		//const float wafLoss = params.waf * ceilings.numCeilingsBetween(position_m, params.position_m);
+		const float wafLoss = params.waf * ceilings.numCeilingsBetweenFloat(position_m, params.position_m);
+		//const float wafLoss = params.waf * ceilings.numCeilingsBetweenLinearInt(position_m, params.position_m);
 
 		// combine
 		const float res = rssiLOS + wafLoss;
@@ -143,6 +162,59 @@ public:
 
 	}
 
+	void writeToXML(XMLDoc* doc, XMLElem* dst) override {
+
+		// set my type
+		dst->SetAttribute("type", "WiFiModelLogDistCeiling");
+
+		for (const auto& it : accessPoints) {
+			const MACAddress& mac = it.first;
+			const APEntry& ape = it.second;
+			XMLElem* xap = doc->NewElement("ap");
+			xap->SetAttribute("mac", mac.asString().c_str());
+			xap->SetAttribute("px", ape.position_m.x);
+			xap->SetAttribute("py", ape.position_m.y);
+			xap->SetAttribute("pz", ape.position_m.z);
+			xap->SetAttribute("txp", ape.txp);
+			xap->SetAttribute("exp", ape.exp);
+			xap->SetAttribute("waf", ape.waf);
+			dst->InsertEndChild(xap);
+		}
+
+		for (const float atHeight_m : ceilings.getCeilings()) {
+			XMLElem* xceil = doc->NewElement("ceiling");
+			xceil->SetAttribute("atHeight", atHeight_m);
+			dst->InsertEndChild(xceil);
+		}
+
+	}
+
+	void readFromXML(XMLDoc* doc, XMLElem* src) override {
+
+		// check type
+		if (std::string("WiFiModelLogDistCeiling") != src->Attribute("type")) {throw Exception("invalid model type");}
+
+		accessPoints.clear();
+		ceilings.clear();
+
+		XML_FOREACH_ELEM_NAMED("ap", xap, src) {
+			MACAddress mac = MACAddress(xap->Attribute("mac"));
+			APEntry ape(
+				Point3(xap->FloatAttribute("px"), xap->FloatAttribute("py"), xap->FloatAttribute("pz")),
+			    xap->FloatAttribute("txp"),
+			    xap->FloatAttribute("exp"),
+			    xap->FloatAttribute("waf")
+			);
+			accessPoints.insert( std::make_pair(mac, ape) );
+		}
+
+		XML_FOREACH_ELEM_NAMED("ceiling", xceil, src) {
+			const float atHeight_m = xceil->FloatAttribute("atHeight");
+			ceilings.addCeiling(atHeight_m);
+		}
+
+	}
+
 };
 
 

sensors/radio/setup/WiFiFingerprint.h

@@ -29,6 +29,8 @@ struct WiFiFingerprint {
 	/** ctor */
 	WiFiFingerprint(const Point3 pos_m) : pos_m(pos_m) {;}
 
+	/** ctor */
+	WiFiFingerprint(const Point3 pos_m, const WiFiMeasurements& measurements) : pos_m(pos_m), measurements(measurements) {;}
 
 
 	/** as each AP might be contained more than once (scanned more than once), group them by MAC and use the average RSSI */

sensors/radio/setup/WiFiFingerprints.h

@@ -4,7 +4,7 @@
 #include <fstream>
 
 #include "WiFiFingerprint.h"
-
+#include <iostream>
 
 /**
  * helper class to load and save fingerprints.