2008-04-11 10:11:29 +02:00
|
|
|
#include "referencepoint.hh"
|
2010-06-02 12:37:43 +02:00
|
|
|
#include "measurement.hh"
|
|
|
|
#include "calibrationrequest.hh"
|
|
|
|
#include "stock.hh"
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
2010-01-04 17:10:42 +01:00
|
|
|
using namespace std ;
|
2010-06-02 12:37:43 +02:00
|
|
|
using std::tr1::unordered_map ;
|
2010-01-04 17:10:42 +01:00
|
|
|
|
|
|
|
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
2010-01-16 12:23:07 +01:00
|
|
|
/* *** Constructors *** */
|
2009-12-11 17:56:31 +01:00
|
|
|
|
|
|
|
|
2010-01-16 12:23:07 +01:00
|
|
|
/**
|
2010-02-16 19:31:25 +01:00
|
|
|
* Clears #requests, but does not deallocate the values pointed by
|
2010-01-16 12:23:07 +01:00
|
|
|
* the elements into it.
|
|
|
|
*/
|
2009-12-07 16:03:53 +01:00
|
|
|
ReferencePoint::~ReferencePoint()
|
2010-05-21 10:35:15 +02:00
|
|
|
{
|
2010-02-16 19:31:25 +01:00
|
|
|
requests.clear() ;
|
2010-05-21 10:35:15 +02:00
|
|
|
}
|
2008-04-11 10:11:29 +02:00
|
|
|
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
|
|
|
|
2010-06-02 12:37:43 +02:00
|
|
|
/* *** Accessors *** */
|
|
|
|
|
|
|
|
|
2011-06-15 15:17:01 +02:00
|
|
|
double ReferencePoint::
|
|
|
|
average_measurements(const std::string &mac_transmitter) const
|
|
|
|
{
|
|
|
|
unordered_map<string, Measurement> measurements(
|
|
|
|
get_all_measurements(mac_transmitter)) ;
|
|
|
|
double avg = 0 ;
|
|
|
|
int n_ss = 0 ;
|
|
|
|
|
|
|
|
for (unordered_map<string, Measurement>::const_iterator i =
|
|
|
|
measurements.begin() ;
|
|
|
|
i != measurements.end() ; ++i)
|
|
|
|
{
|
|
|
|
avg += i->second.get_average_ss() ;
|
|
|
|
++n_ss ;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (avg / n_ss) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
unordered_map<string, Measurement> ReferencePoint::
|
|
|
|
get_all_measurements() const
|
2010-06-02 12:37:43 +02:00
|
|
|
{
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
unordered_map<string, Measurement> all ;
|
2010-06-02 12:37:43 +02:00
|
|
|
|
|
|
|
for (vector<CalibrationRequest*>::const_iterator i = requests.begin() ;
|
|
|
|
i != requests.end() ; ++i)
|
|
|
|
{
|
|
|
|
unordered_map<string, Measurement> measurements =
|
|
|
|
(*i)->get_measurements() ;
|
|
|
|
for (unordered_map<string, Measurement>::const_iterator j =
|
|
|
|
measurements.begin() ; j != measurements.end() ; ++j)
|
|
|
|
if (! all.insert(*j).second)
|
|
|
|
all[j->first].merge(j->second) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
return all ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-15 15:17:01 +02:00
|
|
|
unordered_map<string, Measurement> ReferencePoint::
|
|
|
|
get_all_measurements(const string &mac_transmitter) const
|
|
|
|
{
|
|
|
|
unordered_map<string, Measurement> all ;
|
|
|
|
vector<CalibrationRequest*> requests_trx(
|
|
|
|
get_requests(mac_transmitter)) ;
|
|
|
|
|
|
|
|
for (vector<CalibrationRequest*>::const_iterator i =
|
|
|
|
requests_trx.begin() ;
|
|
|
|
i != requests_trx.end() ; ++i)
|
|
|
|
{
|
|
|
|
unordered_map<string, Measurement> measurements =
|
|
|
|
(*i)->get_measurements() ;
|
|
|
|
for (unordered_map<string, Measurement>::const_iterator j =
|
|
|
|
measurements.begin() ; j != measurements.end() ; ++j)
|
|
|
|
if (! all.insert(*j).second)
|
|
|
|
all[j->first].merge(j->second) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
return all ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param mac_transmitter The MAC address of the transmitting mobile.
|
|
|
|
* @return A vector containing all the requests sent by the mobile.
|
|
|
|
* The returned vector is empty if no request was sent by the mobile.
|
|
|
|
*/
|
|
|
|
const vector<CalibrationRequest*> ReferencePoint::
|
|
|
|
get_requests(const string &mac_transmitter) const
|
|
|
|
{
|
|
|
|
vector<CalibrationRequest*> res ;
|
|
|
|
|
|
|
|
for (vector<CalibrationRequest*>::const_iterator i = requests.begin() ;
|
|
|
|
i != requests.end() ; ++i)
|
|
|
|
if ((*i)->get_mobile()->get_mac_addr() == mac_transmitter)
|
|
|
|
res.push_back(*i) ;
|
|
|
|
|
|
|
|
return res ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-20 11:43:17 +02:00
|
|
|
/**
|
|
|
|
* Note that the requests pointed by the elements of #requests are
|
|
|
|
* actually deleted from the Stock.
|
|
|
|
*/
|
|
|
|
void ReferencePoint::delete_requests()
|
|
|
|
{
|
2011-07-20 17:35:22 +02:00
|
|
|
#ifndef NDEBUG
|
|
|
|
int stock_nb_requests = Stock::nb_calibration_requests() ;
|
|
|
|
#endif // NDEBUG
|
|
|
|
|
2011-07-21 21:39:54 +02:00
|
|
|
for (vector<CalibrationRequest*>::iterator r = requests.begin() ;
|
|
|
|
r != requests.end() ; ++r)
|
|
|
|
Stock::delete_calibration_request(**r) ;
|
2011-06-20 11:43:17 +02:00
|
|
|
|
2011-07-20 17:35:22 +02:00
|
|
|
assert(Stock::nb_calibration_requests() ==
|
|
|
|
stock_nb_requests - requests.size()) ;
|
|
|
|
|
2011-06-20 11:43:17 +02:00
|
|
|
requests.clear() ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-21 21:39:54 +02:00
|
|
|
/**
|
|
|
|
* Note that the requests pointed by the elements of #requests are
|
|
|
|
* actually deleted from the Stock.
|
|
|
|
* @returns \em true if at least one request was deleted.
|
|
|
|
* @returns \em false if the ReferencePoint was left untouched.
|
|
|
|
*/
|
|
|
|
bool ReferencePoint::delete_generated_requests(void)
|
|
|
|
{
|
2011-07-22 10:48:19 +02:00
|
|
|
unsigned int nb_requests = requests.size() ;
|
|
|
|
vector<CalibrationRequest*>::iterator r = requests.begin() ;
|
|
|
|
while (r != requests.end())
|
2011-07-21 21:39:54 +02:00
|
|
|
{
|
|
|
|
assert(*r) ;
|
2011-07-22 10:48:19 +02:00
|
|
|
unordered_map<std::string, AccessPoint>::const_iterator ap ;
|
|
|
|
|
2011-07-21 21:39:54 +02:00
|
|
|
if ((*r)->get_mobile() == NULL)
|
2011-07-22 10:48:19 +02:00
|
|
|
goto delete_request ;
|
2011-07-21 21:39:54 +02:00
|
|
|
|
|
|
|
for (ap = Stock::get_aps().begin() ; ap != Stock::get_aps().end() ;
|
|
|
|
++ap)
|
|
|
|
if ((*r)->get_mobile()->get_mac_addr() ==
|
|
|
|
ap->second.get_mac_addr())
|
|
|
|
break ;
|
|
|
|
|
2011-07-22 10:48:19 +02:00
|
|
|
if (ap != Stock::get_aps().end()) // r still associated with an AP
|
2011-07-21 21:39:54 +02:00
|
|
|
{
|
2011-07-22 10:48:19 +02:00
|
|
|
++r ;
|
|
|
|
continue ; // Do not delete r
|
2011-07-21 21:39:54 +02:00
|
|
|
}
|
2011-07-22 10:48:19 +02:00
|
|
|
|
|
|
|
// r is not assotiated with an AP, delete it
|
|
|
|
delete_request:
|
|
|
|
Stock::delete_calibration_request(**r) ;
|
|
|
|
r = requests.erase(r) ;
|
2011-07-21 21:39:54 +02:00
|
|
|
}
|
|
|
|
|
2011-07-22 10:48:19 +02:00
|
|
|
return nb_requests != requests.size() ;
|
2011-07-21 21:39:54 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-06-02 12:37:43 +02:00
|
|
|
|
|
|
|
/* *** Operations *** */
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
* Before to compute the distance, all the measurements containted in
|
|
|
|
* #requests are put together, as if it was one big request.
|
2011-05-09 16:21:36 +02:00
|
|
|
*
|
|
|
|
* Note: to compute the distance between two requests, one should use
|
|
|
|
* Request::ss_square_distance().
|
2010-06-02 12:37:43 +02:00
|
|
|
*/
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
float ReferencePoint::ss_square_distance(const Request &source) const
|
2010-06-02 12:37:43 +02:00
|
|
|
{
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
assert(! requests.empty()) ;
|
2010-06-02 12:37:43 +02:00
|
|
|
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
unordered_map<string, Measurement>
|
|
|
|
source_measurements(source.get_measurements()),
|
|
|
|
all_measurements(get_all_measurements()) ;
|
2010-06-02 12:37:43 +02:00
|
|
|
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
PosUtil::complete_with_dummy_measurements(
|
|
|
|
all_measurements, source_measurements) ;
|
2010-06-02 12:37:43 +02:00
|
|
|
|
[Positioning] Some ReferencePoint code -> PosUtil
ReferencePoint::complete_with_dummy_measurements(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::complete_with_dummy_measurements(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
ReferencePoint::compute_ss_square_distance(
map<string, Measurement>,
map<string, Measurement>)
becomes PosUtil::ss_square_distance(
unordered_map<string, Measurement>,
unordered_map<string, Measurement>)
map<string, Measurement> ReferencePoint::get_all_measurements_sorted()
is now private, returns an unordered_map instead of a map, and is
renamed ReferencePoint::get_all_measurements().
Note that we now use unordered_maps for these functions. The use of
sorted lists (maps) was useless, as stated in the commit message of
e9eab687 (Wed Jun 2 12:37:43 2010 +0200).
2011-05-09 15:19:01 +02:00
|
|
|
return PosUtil::ss_square_distance(
|
|
|
|
all_measurements, source_measurements) ;
|
2010-06-02 12:37:43 +02:00
|
|
|
}
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
|
|
|
|
2010-06-14 17:15:48 +02:00
|
|
|
/**
|
|
|
|
* @param ap_mac The MAC address of the AccessPoint to work on.
|
|
|
|
* @returns The Friis index associated to the AccessPoint.
|
|
|
|
* @returns 0 if the AP is unknown at this ReferencePoint.
|
|
|
|
*/
|
|
|
|
float ReferencePoint::
|
|
|
|
friis_index_for_ap(const string &ap_mac) const
|
|
|
|
{
|
|
|
|
const AccessPoint &ap = Stock::get_ap(ap_mac) ;
|
|
|
|
|
|
|
|
double ap_freq = ap.get_frequency() ;
|
|
|
|
double const_term =
|
|
|
|
ap.get_antenna_gain()
|
|
|
|
- 20 * log10(4 * M_PI)
|
|
|
|
+ 20 * log10(PosUtil::LIGHT_SPEED / ap_freq)
|
|
|
|
+ ap.get_trx_power() ;
|
|
|
|
|
|
|
|
int nb_friis_idx = 0 ;
|
|
|
|
double friis_idx_sum =
|
|
|
|
friis_indexes_for_ap(ap, const_term, nb_friis_idx) ;
|
|
|
|
|
|
|
|
if (nb_friis_idx == 0)
|
|
|
|
return 0 ;
|
|
|
|
return friis_idx_sum / nb_friis_idx ;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param ap The AccessPoint to work on.
|
|
|
|
* @param const_term The "constant" part of the computation.
|
|
|
|
* @param nb_indexes (result) The number of indexes computed.
|
|
|
|
* @return The sum of all Friis indexes for the AccessPoint.
|
|
|
|
* @returns 0 if the AP is unknown at this ReferencePoint.
|
|
|
|
*/
|
|
|
|
float ReferencePoint::friis_indexes_for_ap(
|
|
|
|
const AccessPoint &ap,
|
|
|
|
const double &const_term,
|
|
|
|
int &nb_indexes) const
|
|
|
|
{
|
|
|
|
nb_indexes = 0 ;
|
|
|
|
double friis_idx_sum = 0 ;
|
|
|
|
|
|
|
|
const string &ap_mac = ap.get_mac_addr() ;
|
2011-07-15 18:26:16 +02:00
|
|
|
float distance = this->distance(ap.get_coordinates()) ;
|
2010-06-14 17:15:48 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute an index for each Measurement in each Request in the
|
|
|
|
* ReferencePoint. The Friis index for the AP is the average of all
|
|
|
|
* these indexes (we do not compute the average in this function).
|
|
|
|
*/
|
|
|
|
for (vector<CalibrationRequest*>::const_iterator request =
|
|
|
|
requests.begin() ; request != requests.end() ; ++request)
|
|
|
|
{
|
|
|
|
const unordered_map<string, Measurement> &measurements =
|
|
|
|
(*request)->get_measurements() ;
|
|
|
|
unordered_map<string, Measurement>::const_iterator measurement =
|
|
|
|
measurements.find(ap_mac) ;
|
|
|
|
if (measurement != measurements.end())
|
|
|
|
{
|
|
|
|
double ss = measurement->second.get_average_ss() ;
|
|
|
|
float mobile_gain =
|
|
|
|
(*request)->get_mobile()->get_antenna_gain() ;
|
|
|
|
friis_idx_sum +=
|
|
|
|
(const_term + mobile_gain - ss)
|
|
|
|
/ (10 * log10(distance)) ;
|
|
|
|
++nb_indexes ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return friis_idx_sum ;
|
|
|
|
}
|
|
|
|
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
2010-01-16 12:23:07 +01:00
|
|
|
/* *** Operators *** */
|
2009-12-11 17:56:31 +01:00
|
|
|
|
|
|
|
|
2010-06-14 17:15:48 +02:00
|
|
|
const ReferencePoint& ReferencePoint::
|
|
|
|
operator=(const ReferencePoint &source)
|
2008-04-11 10:11:29 +02:00
|
|
|
{
|
2010-02-16 19:31:25 +01:00
|
|
|
if (this == &source)
|
2009-12-07 16:03:53 +01:00
|
|
|
return *this ;
|
2008-08-18 18:19:02 +02:00
|
|
|
|
2010-02-16 19:31:25 +01:00
|
|
|
this->Point3D::operator=(source) ;
|
|
|
|
requests = source.requests ;
|
2009-12-07 16:03:53 +01:00
|
|
|
|
|
|
|
return *this ;
|
2008-04-11 10:11:29 +02:00
|
|
|
}
|
|
|
|
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
2010-02-16 19:31:25 +01:00
|
|
|
bool ReferencePoint::operator==(const ReferencePoint &source) const
|
2009-12-11 17:56:31 +01:00
|
|
|
{
|
2010-02-16 19:31:25 +01:00
|
|
|
if (this == &source)
|
2009-12-11 17:56:31 +01:00
|
|
|
return true ;
|
|
|
|
|
|
|
|
return
|
2010-02-16 19:31:25 +01:00
|
|
|
this->Point3D::operator==(source) &&
|
|
|
|
requests == source.requests ;
|
2009-12-11 17:56:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
GuiNuMo : gestion topologie
server.{hh,cc} :
* Utilisation d'une map plutôt que d'une multimap pour stocker la liste
des pièces. Conséquence : les noms des zones doivent être uniques, il
faut donc numéroter les zones des pièces composites (par exemple
« Couloir N1 A » et « Couloir N1 B »).
* Ajout de la fonction inWhichAreas() qui permet d'obtenir la liste des
zones auxquelles appartient un point.
* Modification de la fonction makeWaypointDistancesFromFile() (renommée
makeWaypointListFromFile()) de manière à ce qu'elle calcule la matrice
des distances entre points de passage (lecture d'une liste de points).
Abandon du format décrivant les points en visibilité (voir le fichier
cfg/distances.csv, supprimé à cette révision), puisque nous nous
servons des points de passage et de la description des zones pour
calculer les liens entre points. RESTE À FAIRE : prise en comppte de
la topologie dans le calcul de distance.
* Ajout de deux fonctions areaConnection() qui permettent de récupérer
la liste des points de passage d'une zone, ou faisant l'intersection
entre deux zones.
* Ajout de la fonction distanceTopology, qui calcule la distance entre
deux points en tenant compte de la topologie (zones et points de
passage entre elles).
* Ajout de la fonction makeReferencePointDistances(), qui calcule les
distances entre points de référence, en tenant compte de la
topologie.
* Ajout de la fonction point_vector_idx(), semblable à point_tab_idx()
mais pour un vector<Point>.
referencepoint.{hh,cc} :
* Ajout de l'operator de cast en Point (operator Point()).
area.{hh,cc} :
* Ajout de l'operator==(Area).
cfg/distances.csv
* Suppression de ce fichier obsolète.
git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@47 785a6c6c-259e-4ff1-8b91-dc31627914f0
2008-06-25 16:19:07 +02:00
|
|
|
|
2010-01-04 16:37:18 +01:00
|
|
|
ostream &operator<<(ostream &os, const ReferencePoint &rp)
|
2008-04-11 10:11:29 +02:00
|
|
|
{
|
2010-01-04 16:37:18 +01:00
|
|
|
// Coordinates
|
2011-07-20 09:55:25 +02:00
|
|
|
os << static_cast<Point3D>(rp) ;
|
2010-01-04 16:37:18 +01:00
|
|
|
|
2010-02-16 19:31:25 +01:00
|
|
|
// List of requests
|
2010-02-26 13:09:45 +01:00
|
|
|
if (rp.requests.empty())
|
2011-07-20 09:55:25 +02:00
|
|
|
os << "\nNo request." << '\n' ;
|
2009-05-29 13:46:49 +02:00
|
|
|
else
|
2010-02-16 19:31:25 +01:00
|
|
|
for (vector<CalibrationRequest*>::const_iterator
|
|
|
|
i = rp.requests.begin() ;
|
|
|
|
i != rp.requests.end() ; ++i)
|
2010-06-02 12:38:17 +02:00
|
|
|
os << '\n' << **i ;
|
2008-04-11 10:11:29 +02:00
|
|
|
|
2009-12-07 16:03:53 +01:00
|
|
|
return os ;
|
2010-05-21 10:35:15 +02:00
|
|
|
}
|
2010-06-07 15:09:22 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This is a simple call to hash_value(Point3D), because we do not want
|
|
|
|
* to take care of the CalibrationRequest list to hash the
|
|
|
|
* ReferencePoint.
|
|
|
|
*/
|
|
|
|
size_t hash_value(const ReferencePoint &source)
|
|
|
|
{
|
|
|
|
return hash_value(static_cast<Point3D>(source)) ;
|
|
|
|
}
|