2008-04-11 10:11:29 +02:00
# include "server.hh"
2008-04-30 11:36:55 +02:00
/******* Misc. very usefull functions *******/
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
2008-07-03 15:04:30 +02:00
/* Tronque le float "f" à "n" décimales et le retourne */
inline float round_float ( float f , int n )
2008-05-29 10:48:05 +02:00
{
2008-08-07 15:44:54 +02:00
n = ( int ) pow ( ( double ) 10 , ( double ) n ) ;
float f_dec = modff ( f , & f ) ;
f_dec = floor ( f_dec * n ) / n ;
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
return f + f_dec ;
2008-05-29 10:48:05 +02:00
}
2008-04-15 12:19:15 +02:00
2008-07-03 15:04:30 +02:00
/* Tronque le float "f" à 2 décimales et le retourne */
inline float round_float_2 ( float f )
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
{
2008-08-07 15:44:54 +02:00
return round_float ( f , 2 ) ;
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
}
2008-04-11 10:11:29 +02:00
/* Explodes a string into substrings based on separator sep. Returns a string vector. */
2008-04-30 11:36:55 +02:00
inline vector < string > explode ( const string & input , const char & sep )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
vector < string > vs ;
string tmp ;
unsigned int i ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < input . size ( ) ; i + + )
if ( input [ i ] = = sep )
{
vs . push_back ( tmp ) ;
tmp . clear ( ) ;
}
else
{
tmp . push_back ( input [ i ] ) ;
}
//Last entry, did not encounter a separator.
2008-04-11 10:11:29 +02:00
vs . push_back ( tmp ) ;
tmp . clear ( ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
return vs ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* Function to convert a string to an integer */
2008-04-30 11:36:55 +02:00
inline int string2int ( const string & nb )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
int tmp ;
iss > > tmp ;
return tmp ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* Function to convert a string to an unsigned integer */
2008-04-30 11:36:55 +02:00
inline unsigned int string2uint ( const string & nb )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
unsigned int tmp ;
iss > > tmp ;
return tmp ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* Function to convert a string to a float */
2008-04-30 11:36:55 +02:00
inline float string2float ( const string & nb )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
float tmp ;
iss > > tmp ;
return tmp ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* Function extracts ints from string */
inline vector < int > extractValues ( string buff )
{
2008-08-07 15:44:54 +02:00
unsigned int ptr = 0 ;
vector < int > ret ;
string tmp_field ;
if ( buff [ buff . size ( ) - 1 ] ! = ' ; ' )
buff . push_back ( ' ; ' ) ;
while ( ptr < buff . size ( ) )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
if ( buff [ ptr ] ! = ' ; ' )
tmp_field . push_back ( buff [ ptr ] ) ;
else
{
ret . push_back ( string2int ( tmp_field ) ) ;
tmp_field . clear ( ) ;
}
ptr + + ;
2008-04-11 10:11:29 +02:00
}
2008-08-07 15:44:54 +02:00
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
inline vector < string > extractReferencePointInfoFromBuffer ( const string & buffer_in )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
unsigned int i = 0 ;
string tmp_field ;
vector < string > ret ;
/* Extract coordinates */
/* x */
while ( buffer_in [ i ] ! = ' ; ' )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
i + + ; // go after the ';'
/* y */
while ( buffer_in [ i ] ! = ' ; ' )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
i + + ;
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifndef FRED_CSV_FORMAT // Dans le format Fred, on n'a pas de coordonnée Z.
2008-08-07 15:44:54 +02:00
/* z */
while ( buffer_in [ i ] ! = ' ; ' )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
i + + ;
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
/* Extract direction (not used now) */
while ( buffer_in [ i ] ! = ' ; ' )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
i + + ;
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifdef FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
/* Extract mac address */
while ( buffer_in [ i ] ! = ' ; ' )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
i + + ;
/* Extract scan list */
while ( i < buffer_in . size ( ) )
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
2008-05-07 10:59:06 +02:00
# else // FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
while ( i < = buffer_in . size ( ) )
2008-04-30 11:36:55 +02:00
{
2008-08-07 15:44:54 +02:00
if ( ( buffer_in [ i ] = = ' ; ' | | i = = buffer_in . size ( ) ) & & ! tmp_field . empty ( ) ) // Si on est sur un séparateur et que la valeur lue n'est pas vide,
{
2008-04-30 11:36:55 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " Ajout de la valeur lue : " < < tmp_field < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
ret . push_back ( tmp_field ) ; // on met la valeur lue dans les valeurs de retour.
tmp_field . clear ( ) ;
}
else // Si on n'est pas sur un séparateur,
tmp_field . push_back ( buffer_in [ i ] ) ; // on ajoute le caractère courant à la suite de la valeur lue.
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
i + + ;
}
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
/* Return the vector with each data */
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* ***************************************************************** */
2008-04-30 11:36:55 +02:00
2008-04-15 12:19:15 +02:00
//Server::Server(string ip_addr, int listen_port, int send_port) // FIXME : paramètre send_port inutilisé
2008-08-07 15:44:54 +02:00
Server : : Server ( const string & ap_file , const string & ref_pt_file , const string & ip_addr , const int & listen_port )
2008-04-11 10:11:29 +02:00
{
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::Server() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
/* Open socket */
sockListen = socket ( PF_INET , SOCK_DGRAM , 0 ) ;
sockSend = socket ( PF_INET , SOCK_DGRAM , 0 ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
/* Set addr */
server_addr . sin_family = AF_INET ;
server_addr . sin_port = htons ( listen_port ) ;
server_addr . sin_addr . s_addr = inet_addr ( ip_addr . c_str ( ) ) ;
memset ( server_addr . sin_zero , ' \0 ' , sizeof ( server_addr . sin_zero ) ) ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
/* Bind */
bind ( sockListen , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ) ) ;
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
makeTopologyFromFile ( DEFAULT_TOPOLOGY_FILE ) ; // Initialisation de "area_list".
makeWaypointListFromFile ( DEFAULT_WAYPOINT_FILE ) ; // Initialisation de "waypoint_list" et "waypoint_matrix".
makeReferencePointListFromFile ( ref_pt_file . c_str ( ) ) ; // Initialisation de "reference_point_list".
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/*if (! checkTopology()) // Vérifications.
{
cout < < " Topology flawed. \n Exiting program. " < < endl ;
exit ( 1 ) ; // Si problème, on quitte.
} */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
makeReferencePointDistances ( ) ; // Initialisation de "reference_point_matrix".
makeApListFromFile ( ap_file . c_str ( ) ) ; // Initialisation de "access_point_list".
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::Server() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
Server : : ~ Server ( )
{
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::~Server() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
close ( sockListen ) ;
close ( sockSend ) ;
reference_point_list . clear ( ) ;
access_point_list . clear ( ) ;
client_list . clear ( ) ;
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::~Server() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
void Server : : send_to_client ( const int & cl )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
/* Do not forget to implement later: usefull for a demo */
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
int Server : : receive_data ( )
{
2008-08-07 15:44:54 +02:00
/* Do not forget to implement later: usefull for a demo */
return 0 ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +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
/* Cherche dans quelle(s) zone(s) se situe un point.
* Retourne une map < string , Area > contenant la liste des zones auxquelles le Point " p " appartient .
*/
map < string , Area > Server : : inWhichAreas ( const Point & p )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::inWhichAreas() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
map < string , Area > areas ;
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
2008-08-07 15:44:54 +02:00
for ( map < string , Area > : : iterator it = area_list . begin ( ) ; it ! = area_list . end ( ) ; it + + )
if ( it - > second . containsPoint ( p ) )
areas . insert ( make_pair ( it - > first , it - > second ) ) ;
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::inWhichAreas() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return areas ;
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
}
2008-07-03 15:04:30 +02:00
/* Retourne true si les points "p1" et "p2" sont dans la même zone (ou ont au moins une zone en commun s'ils appartiennent à plusieurs zones).
*/
bool Server : : inTheSameArea ( const Point & p1 , const Point & p2 )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::inTheSameArea() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
map < string , Area > // Liste des zones comportant les points p1 et p2 :
zones1 ( inWhichAreas ( p1 ) ) ,
zones2 ( inWhichAreas ( p2 ) ) ;
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " zones1 ( " < < zones1 . size ( ) < < " ) : [ " ;
for ( map < string , Area > : : iterator it1 = zones1 . begin ( ) ; it1 ! = zones1 . end ( ) ; it1 + + )
cout < < it1 - > first < < ' , ' ;
cout < < " \b ] " ;
cout < < " zones2 ( " < < zones2 . size ( ) < < " ) : [ " ;
for ( map < string , Area > : : iterator it1 = zones2 . begin ( ) ; it1 ! = zones2 . end ( ) ; it1 + + )
cout < < it1 - > first < < ' , ' ;
cout < < " \b ] " ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
if ( zones1 . size ( ) = = 0 | | zones2 . size ( ) = = 0 ) // Si aucune zone ne contient p1 ou p2,
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::inTheSameArea() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return false ; // on quitte.
}
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
for ( map < string , Area > : : iterator it1 = zones1 . begin ( ) ; it1 ! = zones1 . end ( ) ; it1 + + ) // Parcours des zones :
for ( map < string , Area > : : iterator it2 = zones2 . begin ( ) ; it2 ! = zones2 . end ( ) ; it2 + + )
if ( it1 - > second = = it2 - > second ) // Si les deux zones sont identiques,
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::inTheSameArea() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return true ; // p1 et p2 sont dans la même zone.
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::inTheSameArea() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return false ;
2008-07-03 15:04:30 +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
/* Cherche les points de passage communs aux zones "z1" et "z2".
* Retourne un vector < Point > contenant la liste de ces points .
*/
vector < Point > Server : : areaConnection ( const Area & z1 , const Area & z2 )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::areaConnection(Area&, Area&) " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
vector < Point > points ;
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
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < waypoint_list . size ( ) ; i + + )
{
map < string , Area > areas ( inWhichAreas ( waypoint_list [ i ] ) ) ;
if ( areas . find ( z1 . getName ( ) ) ! = areas . end ( ) & & areas . find ( z2 . getName ( ) ) ! = areas . end ( ) )
points . push_back ( waypoint_list [ i ] ) ;
}
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::areaConnection(Area&, Area&) " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return points ;
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
}
/* Cherche les points de passage de la zone "z".
* Retourne un vector < Point > contenant la liste de ces points .
*/
vector < Point > Server : : areaConnection ( const Area & z )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::areaConnection(Area&) " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
vector < Point > points ;
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
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < waypoint_list . size ( ) ; i + + )
{
map < string , Area > areas ( inWhichAreas ( waypoint_list [ i ] ) ) ;
if ( areas . find ( z . getName ( ) ) ! = areas . end ( ) )
points . push_back ( waypoint_list [ i ] ) ;
}
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::areaConnection(Area&) " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return points ;
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
}
/* Calcule la distance entre les points "p1" et "p2" en tenant compte de la topologie.
*/
float Server : : distanceTopology ( const Point & p1 , const Point & p2 )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
map < string , Area >
zones1 ( inWhichAreas ( p1 ) ) ,
zones2 ( inWhichAreas ( p2 ) ) ;
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
2008-08-07 15:44:54 +02:00
if ( zones1 . size ( ) = = 0 | | zones2 . size ( ) = = 0 ) // Si aucune zone ne contient p1 ou p2,
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " Aucune zone ne contient " < < p1 < < " ( " < < zones1 . size ( ) < < " zones) ou " < < p2 < < " ( " < < zones2 . size ( ) < < " zones). " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return - 1 ; // on quitte.
}
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
2008-08-07 15:44:54 +02:00
Area
z1 ( zones1 . begin ( ) - > second ) , // Première zone d'appartenance du point p1. // FIXME : vérifier toutes les zones
z2 ( zones2 . begin ( ) - > second ) ;
vector < Point > connection ;
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
2008-08-07 15:44:54 +02:00
/* *** Cas de la même zone *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
if ( z1 = = z2 ) // Si les points sont dans la même zone,
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < p1 < < " et " < < p2 < < " sont dans la même zone. " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return p1 . distance ( p2 ) ; // la distance entre eux est la distance euclidienne.
}
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
2008-08-07 15:44:54 +02:00
/* *** Cas de deux zones voisines (connectées directement) *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
if ( ( connection = areaConnection ( z1 , z2 ) ) . size ( ) ! = 0 ) // Si les points sont dans deux zones voisines,
{ // la distance entre eux est la distance euclidienne de chacun jusqu'au plus proche point de passage entre les deux zones.
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < p1 < < " et " < < p2 < < " sont dans deux zones voisines. " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
float dist = p1 . distance ( connection [ 0 ] ) + p2 . distance ( connection [ 0 ] ) ;
for ( unsigned int i = 1 ; i < connection . size ( ) ; i + + ) // Recherche du point de passage offrant la plus courte distance
{
float tmp_dist = p1 . distance ( connection [ i ] ) + p2 . distance ( connection [ i ] ) ;
if ( tmp_dist < dist )
dist = tmp_dist ;
}
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return dist ;
}
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
2008-08-07 15:44:54 +02:00
/* *** Les points sont dans des zones non-voisines *** */
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < p1 < < " et " < < p2 < < " sont dans des zones non-voisines. " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
vector < Point > // Liste des points de passage appartenant respectivement à z1 et à z2.
wp_z1 ( areaConnection ( z1 ) ) ,
wp_z2 ( areaConnection ( z2 ) ) ;
int // Indices des points de passage dans la liste :
wp_z1_idx ,
wp_z2_idx = - 1 ; // z2 ne peut pas être utilisé non initialisé, contrairement à ce que dit GCC, car dans le cas où il n'est pas initialisé on quitte la fonction avant de l'utiliser (cf. "return -1" un peu plus bas);
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
2008-08-07 15:44:54 +02:00
if ( wp_z1 . size ( ) = = 0 | | wp_z2 . size ( ) = = 0 ) // Si l'une des deux zones ne comporte aucun point de passage,
{
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return - 1 ; // on quitte (ceci ne devrait jamais se produire).
}
/* Première itération (voir explication de l'algorithme plus bas) */
unsigned int i1 , i2 ;
for ( i1 = 0 ; i1 < wp_z1 . size ( ) ; i1 + + ) // Recherche des premiers indices valides (où il existe un chemin entre les points de passage)
{
wp_z1_idx = pointIndex ( waypoint_list , wp_z1 [ i1 ] ) ;
for ( i2 = 0 ; i2 < wp_z2 . size ( ) ; i2 + + )
{
wp_z2_idx = pointIndex ( waypoint_list , wp_z2 [ i2 ] ) ;
if ( wp_z2_idx < 0 )
continue ;
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
2008-08-07 15:44:54 +02:00
if ( waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] ! = - 1 ) // Si c'est bon,
break ; // on arrête le parcours.
}
if ( waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] ! = - 1 ) // Si c'est bon,
break ; // on arrête le parcours.
}
if ( i1 > = wp_z1 . size ( ) ) // Si on a parcouru tout le tableau sans trouver de chemin,
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
{
2008-08-07 15:44:54 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return - 1 ; // on quitte.
}
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
float
dist = p1 . distance ( wp_z1 [ i1 ] ) + waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] + p2 . distance ( wp_z2 [ i2 ] ) ,
tmp_dist ;
for ( unsigned int j = i2 + 1 ; j < wp_z2 . size ( ) ; j + + ) // Fin du parcours :
{
wp_z2_idx = pointIndex ( waypoint_list , wp_z2 [ j ] ) ;
if ( waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] = = - 1 )
continue ;
tmp_dist = p1 . distance ( wp_z1 [ i1 ] ) + waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] + p2 . distance ( wp_z2 [ j ] ) ;
if ( tmp_dist < dist )
dist = tmp_dist ;
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
}
2008-08-07 15:44:54 +02:00
/* Itérations suivantes */
for ( unsigned int i = i1 + 1 ; i < wp_z1 . size ( ) ; i + + )
for ( unsigned int j = 0 ; j < wp_z2 . size ( ) ; j + + )
{
// Indice des points de passage wp_z1[i] et wp_z2[j] dans la liste des points de passage :
wp_z1_idx = pointIndex ( waypoint_list , wp_z1 [ i ] ) ;
wp_z2_idx = pointIndex ( waypoint_list , wp_z2 [ j ] ) ;
if ( waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] = = - 1 ) // S'il n'existe aucun chemin entre les deux points de passage
continue ;
/* La distance entre p1 et p2 est égale à la somme de :
* - la distance entre p1 et le point de passage courant de z1
* ( distance cartésienne car ils appartiennent à la même zone ) ,
* - la distance entre p2 et le point de passage courant de z2 ( idem ) ,
* - la distance entre les deux points de passages suscités , qui est
* donnée par la matrice des distances entre points de passage
* ( waypoint_matrix ) .
* On conservera bien sûr la somme qui donne le chemin le plus court .
*/
tmp_dist = p1 . distance ( wp_z1 [ i ] ) + waypoint_matrix [ wp_z1_idx ] [ wp_z2_idx ] + p2 . distance ( wp_z2 [ j ] ) ;
if ( tmp_dist < dist )
dist = tmp_dist ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return dist ;
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
}
2008-05-07 10:59:06 +02:00
/* FONCTION POUR RÉTRO-COMPATIBILITÉ.
* Recherche un point de coordonnées ( x ; y ; z ) dans la liste reference_point_list , retourne true s ' il existe , false sinon . */
2008-07-03 15:04:30 +02:00
inline bool Server : : pointExists ( const float & x , const float & y , const float & z ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointExists(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
bool ret = pointExists ( reference_point_list , Point ( x , y , z ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointExists(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-05-07 10:59:06 +02:00
}
/* FONCTION POUR RÉTRO-COMPATIBILITÉ.
* Recherche un Point dans la liste reference_point_list , retourne true s ' il existe , false sinon . */
2008-07-03 15:04:30 +02:00
inline bool Server : : pointExists ( const Point & p ) const
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointExists(&Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
bool ret = pointExists ( reference_point_list , p ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointExists(&Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-05-07 10:59:06 +02:00
}
/* Recherche un point de coordonnées (x;y;z) dans la liste "point_list", retourne true s'il existe, false sinon. */
2008-07-03 15:04:30 +02:00
inline bool Server : : pointExists ( const vector < ReferencePoint > & point_list , const float & x , const float & y , const float & z ) const
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointExists(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
bool ret = pointExists ( point_list , Point ( x , y , z ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointExists(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-05-07 10:59:06 +02:00
}
/* Recherche un Point dans la liste "point_list", retourne true s'il existe, false sinon. */
2008-07-03 15:04:30 +02:00
inline bool Server : : pointExists ( const vector < ReferencePoint > & point_list , const Point & p ) const
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointExists(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
bool ret = ( pointIndex ( point_list , p ) ! = - 1 ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointExists(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-07-03 15:04:30 +02:00
inline int Server : : pointIndex ( const float & x , const float & y , const float & z ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointIndex(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int ret = pointIndex ( reference_point_list , Point ( x , y , z ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-05-07 10:59:06 +02:00
}
2008-04-15 12:19:15 +02:00
2008-05-07 10:59:06 +02:00
2008-07-03 15:04:30 +02:00
inline int Server : : pointIndex ( const Point & p ) const
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointIndex(&Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int ret = pointIndex ( reference_point_list , p ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-07-03 15:04:30 +02:00
inline int Server : : pointIndex ( const vector < ReferencePoint > & point_list , const float & x , const float & y , const float & z ) const
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointIndex(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int ret = pointIndex ( point_list , Point ( x , y , z ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-05-07 10:59:06 +02:00
}
2008-07-03 15:04:30 +02:00
inline int Server : : pointIndex ( const vector < ReferencePoint > & point_list , const Point & p ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int i ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < point_list . size ( ) ; i + + )
if ( p = = point_list [ i ] . getCoordinates ( ) )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return i ;
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
return - 1 ; // Point non trouvé
2008-07-03 15:04:30 +02:00
}
/* Retourne la position du Point "p" dans le tableau à une dimension "point_tab" de taille "size", ou -1 en cas d'échec. */
inline int Server : : pointIndex ( const Point * point_tab , unsigned int & size , const Point & p ) const
{
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < size ; i + + )
if ( point_tab [ i ] = = p )
return i ;
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
return - 1 ;
2008-07-03 15:04:30 +02:00
}
/* Retourne la position du Point "p" dans le vector "point_list", ou -1 en cas d'échec. */
inline int Server : : pointIndex ( const vector < Point > & point_list , const Point & p ) const
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::pointIndex(&vector<Point>, &Point) " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < point_list . size ( ) ; i + + )
if ( point_list [ i ] = = p )
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&vector<Point>, &Point) " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return i ;
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::pointIndex(&vector<Point>, &Point) " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return - 1 ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
bool Server : : apExists ( const string & ap_addr ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::apExists() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
string str ;
2008-06-17 11:08:26 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
{
str = access_point_list [ i ] . getApAddr ( ) ;
const int length = str . length ( ) ;
for ( int j = 0 ; j < length ; + + j )
str [ j ] = std : : tolower ( str [ j ] ) ;
if ( str = = ap_addr )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::apExists() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return true ;
}
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::apExists() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return false ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
unsigned int Server : : apIndex ( const string & ap_addr ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::apIndex() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int i ;
string str ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < access_point_list . size ( ) ; i + + )
{
str = access_point_list [ i ] . getApAddr ( ) ;
const int length = str . length ( ) ;
for ( int j = 0 ; j < length ; + + j )
str [ j ] = std : : tolower ( str [ j ] ) ;
if ( str = = ap_addr )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::apIndex() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return i ;
}
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::apIndex() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
return 0 ; // Should never happen
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
/* Selects the "k" closest points from the measurement "m", in the SS space.
* Returns an empty vector if no points are found , which should never happen .
*/
vector < Point > Server : : getkClosestInSs ( const vector < Measurement > & m , const unsigned int & k ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::getkClosestInSs(&vector<Measurement>, &unsigned int) " < < endl ;
cout < < " //<-- Server::getkClosestInSs(&vector<Measurement>, &unsigned int) " < < endl ;
fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return getkClosestInSs ( m , k , NULL ) ;
2008-04-30 11:36:55 +02:00
}
/* Selects the "k" closest points from the measurement "m", in the SS space.
* If " point_ignored " is not NULL , the Point " *point_ignored " is ignored .
* Returns an empty vector if no points are found , which should never happen .
*/
vector < Point > Server : : getkClosestInSs ( const vector < Measurement > & m , const unsigned int & k , const Point * point_ignored ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::getkClosestInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int i , j , min_idx ;
vector < float > distances_vector ;
vector < Point > points_vector ;
Point tmp_pt ;
float tmp_distance = 0 , dist_max = 10000000 , tmp_min ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
if ( point_ignored = = NULL | | ( reference_point_list [ i ] . getCoordinates ( ) ! = * point_ignored ) )
{
tmp_distance = reference_point_list [ i ] . getSsSquareDistance ( m ) ;
2008-05-07 14:25:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < tmp_distance < < " " ;
2008-05-07 14:25:51 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
/* if not k points, add it */
if ( distances_vector . size ( ) < k )
{
distances_vector . push_back ( tmp_distance ) ;
points_vector . push_back ( reference_point_list [ i ] . getCoordinates ( ) ) ;
dist_max = ( dist_max < tmp_distance ) ? tmp_distance : dist_max ;
}
else
{
/* if tmp_dst < dist_max, should add it and remove previous greatest dist. */
if ( dist_max > tmp_distance )
{
/* remove old max */
for ( j = 0 ; j < distances_vector . size ( ) ; j + + )
if ( distances_vector [ j ] = = dist_max )
{
distances_vector [ j ] = tmp_distance ;
points_vector [ j ] = reference_point_list [ i ] . getCoordinates ( ) ;
break ;
}
/* Now seek the new max. distance */
dist_max = distances_vector [ 0 ] ;
for ( j = 1 ; j < distances_vector . size ( ) ; j + + )
if ( distances_vector [ j ] > dist_max )
dist_max = distances_vector [ j ] ;
}
/* Else nothing needs to be done */
}
}
2008-05-07 14:25:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < endl ;
2008-05-07 14:25:51 +02:00
# endif // DEBUG_2
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
/* Sorts the vector */
for ( i = 0 ; i < distances_vector . size ( ) - 1 ; i + + )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
tmp_min = distances_vector [ i ] ;
min_idx = i ;
for ( j = i + 1 ; j < distances_vector . size ( ) ; j + + )
if ( tmp_min > distances_vector [ j ] )
{
tmp_min = distances_vector [ j ] ;
min_idx = j ;
}
if ( min_idx ! = i )
{
/* Swap points */
tmp_pt = points_vector [ i ] ;
points_vector [ i ] = points_vector [ min_idx ] ;
points_vector [ min_idx ] = tmp_pt ;
/* Swap distances */
distances_vector [ min_idx ] = distances_vector [ i ] ;
distances_vector [ i ] = tmp_min ;
}
2008-04-11 10:11:29 +02:00
}
2008-04-15 12:19:15 +02:00
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " getkClosestInSs() : Points sélectionnés : " < < endl ;
if ( distances_vector . size ( ) ! = points_vector . size ( ) )
cout < < " Erreur ! distances_vector.size()= " < < distances_vector . size ( ) < < " != points_vector.size()= " < < points_vector . size ( ) < < endl ;
else
for ( i = 0 ; i < distances_vector . size ( ) ; i + + )
cout < < distances_vector [ i ] < < " : " < < points_vector [ i ] < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-05-05 13:59:55 +02:00
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::getkClosestInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return points_vector ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
Point Server : : getkWeightedInSs ( const vector < Measurement > & m , const unsigned int & k ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::getkWeightedInSs(&vector<Measurement>, &unsigned int) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
Point ret = getkWeightedInSs ( m , k , NULL ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::getkWeightedInSs(&vector<Measurement>, &unsigned int) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-04-30 11:36:55 +02:00
}
/* If "point_ignored" is not NULL, the Point "*point_ignored" is ignored.
*/
Point Server : : getkWeightedInSs ( const vector < Measurement > & m , const unsigned int & k , const Point * point_ignored ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::getkWeightedInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
unsigned int i , j ;
vector < float > distances_vector ;
vector < Point > points_vector ;
float tmp_distance = 0 , dist_max = 10000000 ;
Point ret ;
float total = 0 , x = 0 , y = 0 , z = 0 ;
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
if ( point_ignored = = NULL | | ( reference_point_list [ i ] . getCoordinates ( ) ! = * point_ignored ) )
{
tmp_distance = reference_point_list [ i ] . getSsSquareDistance ( m ) ;
/* if not k points, add it */
if ( distances_vector . size ( ) < k )
{
distances_vector . push_back ( tmp_distance ) ;
points_vector . push_back ( reference_point_list [ i ] . getCoordinates ( ) ) ;
dist_max = ( dist_max < tmp_distance ) ? tmp_distance : dist_max ;
}
else
{
/* if tmp_dst < dist_max, should add it and remove previous greatest dist. */
if ( dist_max > tmp_distance )
{
/* remove old max */
for ( j = 0 ; j < distances_vector . size ( ) ; j + + )
if ( distances_vector [ j ] = = dist_max )
{
dist_max = tmp_distance ;
distances_vector . erase ( distances_vector . begin ( ) + j ) ;
points_vector . erase ( points_vector . begin ( ) + j ) ;
distances_vector . push_back ( tmp_distance ) ;
points_vector . push_back ( reference_point_list [ i ] . getCoordinates ( ) ) ;
break ;
}
}
/* Else nothing needs to be done */
}
}
for ( i = 0 ; i < distances_vector . size ( ) ; i + + )
total + = ( 1 / distances_vector [ i ] ) ;
for ( i = 0 ; i < distances_vector . size ( ) ; i + + )
{
x + = points_vector [ i ] . getX ( ) * ( 1 / distances_vector [ i ] ) / total ;
y + = points_vector [ i ] . getY ( ) * ( 1 / distances_vector [ i ] ) / total ;
z + = points_vector [ i ] . getZ ( ) * ( 1 / distances_vector [ i ] ) / total ;
}
ret . setX ( x ) ;
ret . setY ( y ) ;
ret . setZ ( z ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::getkWeightedInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
Point Server : : kPointsAverage ( const vector < Point > & vp ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::kPointsAverage() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int i ;
float x = 0 , y = 0 , z = 0 ;
Point p ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < vp . size ( ) ; i + + )
{
x + = vp [ i ] . getX ( ) ;
y + = vp [ i ] . getY ( ) ;
z + = vp [ i ] . getZ ( ) ;
}
p . setX ( x / ( float ) vp . size ( ) ) ;
p . setY ( y / ( float ) vp . size ( ) ) ;
p . setZ ( z / ( float ) vp . size ( ) ) ;
2008-04-15 12:19:15 +02:00
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::kPointsAverage() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return p ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
Point Server : : fbcm ( const vector < Measurement > & m , const int & client_idx ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::fbcm() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
Point ret ( 0 , 0 , 0 ) ;
vector < string > addr ;
vector < float > dist_vect ;
vector < Point > centres ;
unsigned int i , ap_idx ;
float constant_term , minmax_res , minmax_max ;
float x = MINMAX_X_START , y = MINMAX_Y_START , z = MINMAX_Z_START ;
i = 0 ;
//cout << "FBCM: ";
for ( i = 0 ; i < m . size ( ) ; i + + )
if ( apExists ( m [ i ] . getMacAddr ( ) ) )
{
ap_idx = apIndex ( m [ i ] . getMacAddr ( ) ) ;
//cout << "AP idx: " << ap_idx << " ";
centres . push_back ( access_point_list [ ap_idx ] . getCoordinates ( ) ) ;
addr . push_back ( m [ i ] . getMacAddr ( ) ) ;
constant_term = access_point_list [ ap_idx ] . getOutputPower ( ) + access_point_list [ ap_idx ] . getAntennaGain ( ) + 2 ;
constant_term + = 20 * log10 ( ( 300000000.0 / ( float ) access_point_list [ ap_idx ] . getFrequency ( ) ) / ( 4 * M_PI ) ) ;
//end of expr. should be: client_list[client_idx].getAntennaGain() instead of 2.
//cout << "20log(" << (300000000.0 / (float) access_point_list[ap_idx].getFrequency()) / (4*M_PI) << ") = ";
//cout << constant_term << " ";
dist_vect . push_back ( pow ( 10 , ( constant_term - m [ i ] . getAverage ( ) ) / ( 10 * access_point_list [ ap_idx ] . getFriisIndex ( ) ) ) ) ;
//cout << endl;
}
/* Then: min-max */
minmax_res = 1000000 ;
for ( x = MINMAX_X_START ; x < MINMAX_X_STOP ; x + = MINMAX_STEP )
for ( y = MINMAX_Y_START ; y < MINMAX_Y_STOP ; y + = MINMAX_STEP )
for ( z = MINMAX_Z_START ; z < = MINMAX_Z_STOP ; z + = MINMAX_STEP )
{
minmax_max = 0 ;
for ( i = 0 ; i < centres . size ( ) ; i + + )
if ( abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) > minmax_max )
minmax_max = abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
{
ret . setX ( x ) ;
ret . setY ( y ) ;
ret . setZ ( z ) ;
minmax_res = minmax_max ;
}
}
/* Clear all vectors */
addr . clear ( ) ;
dist_vect . clear ( ) ;
centres . clear ( ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::fbcm() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
/* Return position */
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-06-17 11:08:26 +02:00
/*second version of fbcm with as parameter vector<Measurement> &m and a list of friis index*/
2008-07-17 10:19:15 +02:00
Point Server : : fbcm_friis ( const vector < Measurement > & m , const vector < float > friis_idx_list , const float & z ) const
2008-06-17 11:08:26 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::fbcm_friis() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
Point ret ( 0 , 0 , 0 ) ;
//vector<string> addr;
vector < float > dist_vect ;
vector < Point > centres ;
unsigned int i , j , ap_idx ;
float constant_term , minmax_res , minmax_max ;
float x = MINMAX_X_START , y = MINMAX_Y_START ;
2008-08-18 18:19:02 +02:00
vector < Measurement > vm = m ; //Used when filtering 3 strongest APs
vector < float > friis_idx = friis_idx_list ; //Used when filtering 3 strongest APs
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
i = 0 ;
//cout << "FBCM: ";
2008-08-18 18:19:02 +02:00
cout < < " Received " < < vm . size ( ) < < " measurements. " < < endl ;
for ( i = 0 ; i < vm . size ( ) ; i + + )
2008-07-22 15:17:53 +02:00
{
2008-08-18 18:19:02 +02:00
if ( apExists ( vm [ i ] . getMacAddr ( ) ) )
2008-08-07 15:44:54 +02:00
{
2008-08-18 18:19:02 +02:00
ap_idx = apIndex ( vm [ i ] . getMacAddr ( ) ) ;
cout < < " AP " < < vm [ i ] . getMacAddr ( ) < < " was found at position " < < ap_idx < < endl ;
2008-08-07 15:44:54 +02:00
constant_term = access_point_list [ ap_idx ] . getOutputPower ( ) + access_point_list [ ap_idx ] . getAntennaGain ( ) + 2 ;
constant_term + = 20 * log10 ( ( 300000000.0 / ( float ) access_point_list [ ap_idx ] . getFrequency ( ) ) / ( 4 * M_PI ) ) ;
2008-08-18 18:19:02 +02:00
if ( friis_idx [ i ] ! = - 1 )
2008-08-07 15:44:54 +02:00
{
centres . push_back ( access_point_list [ ap_idx ] . getCoordinates ( ) ) ;
2008-08-18 18:19:02 +02:00
dist_vect . push_back ( pow ( 10 , ( constant_term - vm [ i ] . getAverage ( ) ) / ( 10 * friis_idx [ i ] ) ) ) ;
2008-08-07 15:44:54 +02:00
}
}
2008-07-22 15:17:53 +02:00
}
2008-08-07 15:44:54 +02:00
cout < < " Computed " < < dist_vect . size ( ) < < " Friis indexes. Values: " < < endl ;
for ( j = 0 ; j < dist_vect . size ( ) ; j + + )
cout < < " dist_vect du point d'accés: " < < centres [ j ] < < " --->>> " < < dist_vect [ j ] < < endl ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
/* Then: min-max */
minmax_res = 1000000 ;
for ( x = MINMAX_X_START ; x < MINMAX_X_STOP ; x + = MINMAX_STEP )
for ( y = MINMAX_Y_START ; y < MINMAX_Y_STOP ; y + = MINMAX_STEP )
{
minmax_max = 0 ;
for ( i = 0 ; i < centres . size ( ) ; i + + )
if ( abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) > minmax_max )
minmax_max = abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
{
ret . setX ( x ) ;
ret . setY ( y ) ;
ret . setZ ( z ) ;
minmax_res = minmax_max ;
}
}
/* Clear all vectors */
// addr.clear();
dist_vect . clear ( ) ;
centres . clear ( ) ;
//cout << "RESULTAT DU FRBHM ---> " << ret << endl ;
2008-04-15 12:19:15 +02:00
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::fbcm_friis() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* Return position */
return ret ;
}
Point Server : : interlink ( const vector < Measurement > & m , const int & client_idx ) const
{
# ifdef DEBUG_T
cout < < " //--> Server::interlink() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
Point ret ( 0 , 0 , 0 ) ;
vector < string > addr ;
vector < float > dist_vect ;
vector < Point > centres ;
unsigned int i , ap_idx ;
float constant_term , minmax_res , minmax_max ;
float x = MINMAX_X_START , y = MINMAX_Y_START , z = MINMAX_Z_START ;
i = 0 ;
for ( i = 0 ; i < m . size ( ) ; i + + )
if ( apExists ( m [ i ] . getMacAddr ( ) ) )
{
ap_idx = apIndex ( m [ i ] . getMacAddr ( ) ) ;
centres . push_back ( access_point_list [ ap_idx ] . getCoordinates ( ) ) ;
addr . push_back ( m [ i ] . getMacAddr ( ) ) ;
constant_term = access_point_list [ ap_idx ] . getOutputPower ( ) + access_point_list [ ap_idx ] . getAntennaGain ( ) ;
constant_term + = 20 * log10 ( ( 300000000.0 / ( float ) access_point_list [ ap_idx ] . getFrequency ( ) ) / ( 4 * M_PI ) ) + 2 ;
//end of expr. should be: client_list[client_idx].getAntennaGain() instead of 2.
dist_vect . push_back ( pow ( 10 , ( constant_term - m [ i ] . getAverage ( ) ) / 35 ) ) ;
}
/* Then: min-max */
minmax_res = 1000000 ;
for ( x = MINMAX_X_START ; x < MINMAX_X_STOP ; x + = MINMAX_STEP )
for ( y = MINMAX_Y_START ; y < MINMAX_Y_STOP ; y + = MINMAX_STEP )
for ( z = MINMAX_Z_START ; z < MINMAX_Z_STOP ; z + = MINMAX_STEP )
{
minmax_max = 0 ;
for ( i = 0 ; i < centres . size ( ) ; i + + )
if ( abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) > minmax_max )
minmax_max = abs ( centres [ i ] . distance ( x , y , z ) - dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
{
ret . setX ( x ) ;
ret . setY ( y ) ;
ret . setZ ( z ) ;
minmax_res = minmax_max ;
}
}
/* Clear all vectors */
addr . clear ( ) ;
dist_vect . clear ( ) ;
centres . clear ( ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::interlink() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
/* Return position */
return ret ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-05-05 13:59:55 +02:00
/* FONCTION POUR RÉTRO-COMPATIBILITÉ.
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
* Crée la liste des points de référence dans la liste reference_point_list .
*/
2008-04-30 11:36:55 +02:00
void Server : : makeReferencePointListFromFile ( const string & filename )
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makePointListFromFile(&string) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
makePointListFromFile ( reference_point_list , filename , true ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makePointListFromFile(&string) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-05 13:59:55 +02:00
}
void Server : : makePointListFromFile ( vector < ReferencePoint > & dest_point_list , const string & filename )
2008-05-07 10:59:06 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makePointListFromFile(&vector<ReferencePoint>, &string) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
makePointListFromFile ( dest_point_list , filename , true ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makePointListFromFile(&vector<ReferencePoint>, &string) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-07 10:59:06 +02:00
}
/* Lit le fichier de mesures (CSV) nommé "filename", et place les informations dans la liste "dest_point_list".
* Si " uniq_point " est vrai , on vérifiera l ' existence d ' un point avant tout ajout d ' information , de manière à ne pas créer de doublon : si le point existe déjà , les informations lui seront ajoutées , sinon un nouveau point sera créé dans la liste .
* Si " uniq_point " est faux , un nouveau point sera créé pour chaque ligne du fichier .
*/
void Server : : makePointListFromFile ( vector < ReferencePoint > & dest_point_list , const string & filename , const bool uniq_point )
2008-05-05 13:59:55 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makePointListFromFile(&vector<ReferencePoint>, &string, bool) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
ifstream input_file ; // Flux d'entrée du fichier.
char buffer [ BUFFER_LENGTH ] ; // Buffer lu dans le fichier.
string cpp_buffer ; // Buffer au format string.
ReferencePoint rp ;
Point tmp_point ;
float x , y , z ; // Coordonnées des points.
unsigned int pt_idx = 0 ; // Position du point lu dans la liste.
vector < string > infos ; // Liste des informations lues dans une ligne du fichier.
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
input_file . open ( filename . c_str ( ) ) ;
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Lecture du fichier « " < < filename < < " »... " ;
int nlines = 0 ;
int npoints = 0 ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
while ( ! input_file . eof ( ) )
{
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
if ( nlines % 100 = = 0 )
printf ( " \n %5d " , nlines ) ;
cout < < ' . ' ;
nlines + + ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
input_file . getline ( buffer , BUFFER_LENGTH ) ;
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
{
/* Extract fields */
cpp_buffer = buffer ;
if ( cpp_buffer . size ( ) = = 0 ) // Ignorer une ligne vide
continue ;
infos = extractReferencePointInfoFromBuffer ( cpp_buffer ) ;
x = string2float ( infos [ 0 ] ) ;
y = string2float ( infos [ 1 ] ) ;
2008-04-30 11:36:55 +02:00
# ifdef FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
z = DEFAULT_Z ;
2008-05-07 10:59:06 +02:00
# else // FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
z = string2float ( infos [ 2 ] ) ;
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
/* Set point coordinates */
tmp_point . setX ( x ) ;
tmp_point . setY ( y ) ;
tmp_point . setZ ( z ) ;
/* Use C++ string format */
if ( ! uniq_point | | ! pointExists ( dest_point_list , tmp_point ) ) // Si on ne veut pas de points unique, ou que le point n'existe pas encore,
{
rp . setCoordinates ( tmp_point ) ;
dest_point_list . push_back ( rp ) ; // on le crée.
pt_idx = dest_point_list . size ( ) - 1 ; // Le point que l'on vient d'ajouter est le dernier du vector.
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
npoints + + ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-05-05 13:59:55 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < tmp_point < < " : ajouté. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
}
else // Le point existe déjà :
{
2008-05-07 10:59:06 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < tmp_point < < " : existe déjà. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
pt_idx = pointIndex ( dest_point_list , tmp_point ) ; // On recherche le point auquel on veut ajouter les informations.
}
2008-04-30 11:36:55 +02:00
# ifdef FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
vector < int > measures_vector = extractValues ( infos [ 4 ] ) ;
for ( unsigned int i = 0 ; i < measures_vector . size ( ) ; i + + )
dest_point_list [ pt_idx ] . addMeasurement ( infos [ 3 ] , measures_vector [ i ] ) ;
measures_vector . clear ( ) ;
2008-05-07 10:59:06 +02:00
# else // FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 4 ; i < infos . size ( ) ; i + + )
{
2008-04-30 11:36:55 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " Lecture de la valeur : " < < infos [ i ] < < " ... " ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
if ( i + 1 < infos . size ( ) )
{
dest_point_list [ pt_idx ] . addMeasurement ( infos [ i ] , string2int ( infos [ i + 1 ] ) ) ;
2008-04-30 11:36:55 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " Mesure ajoutée : AP = " < < infos [ i ] < < " | SS = " < < string2int ( infos [ i + 1 ] ) < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
i + + ;
}
}
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
2008-08-07 15:44:54 +02:00
}
2008-04-11 10:11:29 +02:00
}
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < ' \n ' < < nlines < < " lignes lues, " < < npoints < < " points différents ajoutés. \n " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
input_file . close ( ) ;
infos . clear ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makePointListFromFile(&vector<ReferencePoint>, &string, bool) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
void Server : : makeApListFromFile ( const string & filename )
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makeApListFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
ifstream input_file ;
char buffer [ BUFFER_LENGTH ] ;
vector < string > ap_infos ;
AccessPoint tmp_ap ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
input_file . open ( filename . c_str ( ) ) ;
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Lecture du fichier « " < < filename < < " »... " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
while ( ! input_file . eof ( ) )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
input_file . getline ( buffer , BUFFER_LENGTH ) ;
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
{
/* Traitement basique des commentaires */
if ( buffer [ 0 ] = = ' \0 ' // Ligne vide
| | buffer [ 0 ] = = ' # ' ) // ou ligne commençant par #
continue ; // ignorer cette ligne.
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
ap_infos = explode ( buffer , ' ; ' ) ;
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " AP : " < < buffer ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
tmp_ap . setApAddr ( ap_infos [ 0 ] ) ;
tmp_ap . setCoordinates ( string2float ( ap_infos [ 1 ] ) , string2float ( ap_infos [ 2 ] ) , string2float ( ap_infos [ 3 ] ) ) ;
tmp_ap . setFrequency ( string2uint ( ap_infos [ 4 ] ) ) ;
tmp_ap . setAntennaGain ( string2float ( ap_infos [ 5 ] ) ) ;
tmp_ap . setOutputPower ( string2float ( ap_infos [ 6 ] ) ) ;
access_point_list . push_back ( tmp_ap ) ;
ap_infos . clear ( ) ;
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " ajouté. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-04-11 10:11:29 +02:00
}
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
input_file . close ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makeApListFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +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
/* Lit la liste des zones homogènes du bâtiment (pièces) dans le fichier "filename", et place le résultat dans "area_list". */
2008-05-29 10:48:05 +02:00
void Server : : makeTopologyFromFile ( const string & filename )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makeTopologyFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
ifstream input_file ;
char buffer [ BUFFER_LENGTH ] ;
vector < string > infos ;
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
input_file . open ( filename . c_str ( ) ) ;
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Lecture du fichier « " < < filename < < " »... " < < endl ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
while ( ! input_file . eof ( ) )
2008-05-29 10:48:05 +02:00
{
2008-08-07 15:44:54 +02:00
input_file . getline ( buffer , BUFFER_LENGTH ) ;
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
{
/* Traitement basique des commentaires */
if ( buffer [ 0 ] = = ' \0 ' // Ligne vide
| | buffer [ 0 ] = = ' # ' ) // ou ligne commençant par #
continue ; // ignorer cette ligne.
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
infos = explode ( buffer , ' ; ' ) ;
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Pièce : " < < buffer ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
if ( area_list . find ( infos [ 0 ] ) ! = area_list . end ( ) ) // Si la pièce existe déjà,
cerr < < " Erreur ! Déclaration multiple de la zone « " < < infos [ 0 ] < < " ». " < < endl ; // on le signale ;
else // sinon on l'ajoute :
{
area_list [ infos [ 0 ] ] = Area ( infos [ 0 ] , string2float ( infos [ 1 ] ) , string2float ( infos [ 3 ] ) , string2float ( infos [ 2 ] ) , string2float ( infos [ 4 ] ) , string2float ( infos [ 5 ] ) , string2float ( infos [ 6 ] ) ) ;
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " ajoutée. " < < endl ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
infos . clear ( ) ;
}
2008-05-29 10:48:05 +02:00
}
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " --> Liste des pièces ( " < < area_list . size ( ) < < " ) : " < < endl ;
for ( map < string , Area > : : iterator it = area_list . begin ( ) ; it ! = area_list . end ( ) ; it + + )
cout < < it - > first < < " : " < < it - > second < < endl ;
cout < < endl ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
input_file . close ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makeTopologyFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-29 10:48:05 +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
/* Lit la liste des points de passage dans le fichier "filename" et calcule les distances entre eux. Initialise waypoint_list et waypoint_matrix.
* TODO : tenir compte de la topologie pour les distances entre points .
*/
void Server : : makeWaypointListFromFile ( const string & filename )
2008-05-29 10:48:05 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* *** Lecture du fichier *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
ifstream input_file ;
char buffer [ BUFFER_LENGTH ] ;
vector < string > infos ;
set < Point > point_list ;
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
input_file . open ( filename . c_str ( ) ) ;
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
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
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ;
}
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Lecture du fichier « " < < filename < < " »... " < < endl ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
while ( ! input_file . eof ( ) )
2008-05-29 10:48:05 +02:00
{
2008-08-07 15:44:54 +02:00
input_file . getline ( buffer , BUFFER_LENGTH ) ;
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
{
/* Traitement basique des commentaires */
if ( buffer [ 0 ] = = ' \0 ' // Ligne vide
| | buffer [ 0 ] = = ' # ' ) // ou ligne commençant par #
continue ; // ignorer cette ligne.
infos = explode ( buffer , ' ; ' ) ;
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Point de passage : " < < buffer < < ' ' ; fflush ( stdout ) ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
/* Ajout du point lu */
Point tmp_pt ( string2float ( infos [ 0 ] ) , string2float ( infos [ 1 ] ) , string2float ( infos [ 2 ] ) ) ;
if ( ! point_list . insert ( tmp_pt ) . second )
cerr < < " Point " < < tmp_pt < < " non ajouté ! Peut-être est-il dupliqué ? " < < endl ;
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
else
cout < < " traité. " < < endl ; fflush ( stdout ) ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
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
2008-08-07 15:44:54 +02:00
infos . clear ( ) ;
}
2008-05-29 10:48:05 +02:00
}
2008-08-07 15:44:54 +02:00
input_file . close ( ) ; // Lecture du fichier terminée
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
/* *** Construction de la matrice des distances *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
unsigned int nb_pts = point_list . size ( ) ; // Nombre de points
unsigned int cur_idx = 0 ; // Itérateur sur l'indice de la matrice.
waypoint_list . reserve ( nb_pts ) ; // Vector contenant tous les points (attribut du serveur)
waypoint_matrix = new float * [ nb_pts ] ; // Matrice (carrée) des distances entre les points de passage (attribut du serveur)
for ( unsigned int i = 0 ; i < nb_pts ; i + + ) // Initialisation de la matrice :
{
waypoint_matrix [ i ] = new float [ nb_pts ] ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + ) // Initialisation des distances à -1
waypoint_matrix [ i ] [ k ] = - 1 ;
}
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
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Traitement des points de passage ( " < < nb_pts < < " )... " ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " --> Liste des points de passage ( " < < nb_pts < < " ) : " < < endl ; fflush ( stdout ) ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
2008-05-29 10:48:05 +02:00
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* Initialisation (voisinage de premier ordre de chaque point */
for ( set < Point > : : iterator it = point_list . begin ( ) ; it ! = point_list . end ( ) ; it + + , cur_idx + + ) // Pour chaque point enregistré
{
2008-05-29 10:48:05 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
if ( cur_idx % 100 = = 0 )
printf ( " \n %5d " , cur_idx ) ;
cout < < ' . ' ;
fflush ( stdout ) ;
2008-05-29 10:48:05 +02:00
# endif // DEBUG
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < * it < < " : " ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
waypoint_list . push_back ( * it ) ; // Ajout du point dans waypoint_list
waypoint_matrix [ cur_idx ] [ cur_idx ] = 0 ; // La distance du point à lui-même est nulle
2008-05-29 10:48:05 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int k = 0 ; k < cur_idx ; k + + ) // Pour chacun des point précédent
{
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " / " < < waypoint_list [ k ] ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
if ( inTheSameArea ( waypoint_list [ cur_idx ] , waypoint_list [ k ] ) ) // Si le point est dans la même zone,
{
float dist = it - > distance ( waypoint_list [ k ] ) ; // on calcule la distance
waypoint_matrix [ cur_idx ] [ k ] = dist ; // et on l'insère dans le tableau,
waypoint_matrix [ k ] [ cur_idx ] = dist ; // dans les deux sens.
}
}
2008-05-29 10:48:05 +02:00
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " / " < < endl ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
}
2008-05-29 10:48:05 +02:00
2008-07-04 11:27:51 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < endl ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
/* Premier affichage de la matrice */
cout < < " --> Matrice des distances entre points de passage (après initialisation) : \n \t \t | " ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
cout < < ' ' < < waypoint_list [ k ] < < " \t | " ;
cout < < endl ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
{
cout < < waypoint_list [ k ] < < " \t | " ;
for ( unsigned int l = 0 ; l < nb_pts ; l + + )
cout < < ' \t ' < < waypoint_matrix [ k ] [ l ] < < " \t | " ;
cout < < endl ;
}
cout < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
/* Itérations suivantes */
bool comput_done = true ;
while ( comput_done )
{
comput_done = false ;
for ( unsigned int i = 0 ; i < nb_pts ; i + + )
for ( unsigned int j = 0 ; j < nb_pts ; j + + )
if ( waypoint_matrix [ i ] [ j ] > 0 )
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
if ( waypoint_matrix [ j ] [ k ] > 0 )
{
/* /!\
* NE PAS OPTIMISER ( g + + - O0 ) !
* Avec l ' option d ' optimisation de GCC ( - O1 , - O2 ou - O3 ) , le test :
* ( tmp_dist < round_float_2 ( waypoint_matrix [ i ] [ k ] ) | | waypoint_matrix [ i ] [ k ] = = - 1 )
* est vrai , même si les deux comparaisons sont fausses .
* Cela semble provenir de la variable tmp_dist .
*/
float tmp_dist = round_float_2 ( waypoint_matrix [ j ] [ k ] + waypoint_matrix [ i ] [ j ] ) ;
if ( tmp_dist < round_float_2 ( waypoint_matrix [ i ] [ k ] ) | | waypoint_matrix [ i ] [ k ] = = - 1 )
{
waypoint_matrix [ i ] [ k ] = tmp_dist ;
comput_done = true ;
}
}
}
2008-07-03 15:04:30 +02:00
2008-05-29 10:48:05 +02:00
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
/* Deuxième affichage de la matrice */
cout < < " --> Matrice des distances entre points de passage : \n \t \t | " ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
cout < < ' ' < < waypoint_list [ k ] < < " \t | " ;
cout < < endl ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
{
cout < < waypoint_list [ k ] < < " \t | " ;
for ( unsigned int l = 0 ; l < nb_pts ; l + + )
cout < < ' \t ' < < waypoint_matrix [ k ] [ l ] < < " \t | " ;
cout < < endl ;
}
cout < < endl ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
}
2008-07-03 15:04:30 +02:00
/* Vérifie la cohérence de la topologie décrite dans les fichiers de configuration.
* Retourne false si un problème est détecté , true sinon .
* / ! \ La liste des * points de passage * , leur * matrice de distances * , ainsi que la liste des * points de référence * , DOIVENT Ê TRE INITIALISÉES avant l ' appel à cette fonction . Il faut donc appeler makeWaypointListFromFile ( ) et makeReferencePointListFromFile ( ) avant checkTopology ( ) .
*/
bool Server : : checkTopology ( )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::checkTopology() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
bool ret = true ;
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* *** Recherche de points de passage n'appartenant à aucune zone *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < waypoint_list . size ( ) ; i + + )
2008-07-03 15:04:30 +02:00
{
2008-08-07 15:44:54 +02:00
map < string , Area > areas ( inWhichAreas ( waypoint_list [ i ] ) ) ;
if ( areas . empty ( ) )
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Le point de passage " < < waypoint_list [ i ] < < " n'appartient à aucune zone ! " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
ret = false ;
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
else
{
cout < < " Le point de passage " < < waypoint_list [ i ] < < " appartient aux zones suivantes : " < < endl ;
for ( map < string , Area > : : iterator it = areas . begin ( ) ; it ! = areas . end ( ) ; it + + )
cout < < ' \t ' < < it - > first < < endl ;
}
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
}
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* *** Recherche de points de référence n'appartenant à aucune zone *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < reference_point_list . size ( ) ; i + + )
2008-07-03 15:04:30 +02:00
{
2008-08-07 15:44:54 +02:00
map < string , Area > areas ( inWhichAreas ( ( Point ) reference_point_list [ i ] ) ) ;
if ( areas . empty ( ) )
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Le point de référence " < < ( Point ) reference_point_list [ i ] < < " n'appartient à aucune zone ! " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
ret = false ; // À modifier si on veut permettre aux points de référence de n'appartenir à aucune zone.
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
else
{
cout < < " Le point de référence " < < ( Point ) reference_point_list [ i ] < < " appartient aux zones suivantes : " < < endl ;
for ( map < string , Area > : : iterator it = areas . begin ( ) ; it ! = areas . end ( ) ; it + + )
cout < < ' \t ' < < it - > first < < endl ;
}
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
}
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
/* *** Recherche des pièces non connectées (et liste des connexions entre pièces) *** */
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
set < string > connected_areas ; // Liste des zones connectées à au moins une autre zone (on n'enregistre que le nom des zones, dupliquer toutes les zones étant inutile).
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
for ( map < string , Area > : : iterator it1 = area_list . begin ( ) ; it1 ! = area_list . end ( ) ; it1 + + )
for ( map < string , Area > : : iterator it2 = area_list . begin ( ) ; it2 ! = area_list . end ( ) ; it2 + + )
{
if ( it1 = = it2 )
continue ;
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
vector < Point > connect ( areaConnection ( it1 - > second , it2 - > second ) ) ;
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
if ( ! connect . empty ( ) )
{
connected_areas . insert ( it1 - > first ) ; // Ajout de la zone à la liste des zones connectées.
2008-07-03 15:04:30 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Les zones « " < < it1 - > first < < " » et « " < < it2 - > first < < " » sont connectées par les points suivants : " < < endl ;
for ( unsigned int i = 0 ; i < connect . size ( ) ; i + + )
cout < < ' \t ' < < connect [ i ] < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
else
cout < < " Les zones « " < < it1 - > first < < " » et « " < < it2 - > first < < " » ne sont pas connectées. " < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
}
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
if ( connected_areas . size ( ) ! = area_list . size ( ) )
{
2008-07-03 15:04:30 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
map < string , Area > orphan_areas ( area_list ) ; // Liste des zones orphelines (non-connectées). Copie de la liste des zones (on devrait utiliser un set ne contenant que les noms, comme pour "connected_areas", mais c'est plus compliqué à coder alors on ne va pas s'embêter, surtout pour un affichage de débogage).
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
for ( set < string > : : iterator it = connected_areas . begin ( ) ; it ! = connected_areas . end ( ) ; it + + )
orphan_areas . erase ( * it ) ; // On supprime chaque zone connectée de la liste des zones orphelines.
2008-07-03 15:04:30 +02:00
2008-08-07 15:44:54 +02:00
cout < < " Les zones suivantes ne sont connectées à aucune autre : " < < endl ;
for ( map < string , Area > : : iterator it = orphan_areas . begin ( ) ; it ! = orphan_areas . end ( ) ; it + + )
cout < < ' \t ' < < it - > first < < endl ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
ret = false ;
}
2008-07-03 15:04:30 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::checkTopology() " < < endl ; fflush ( stdout ) ;
2008-07-03 15:04:30 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ret ;
2008-07-03 15:04:30 +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
/* Calcule la distance entre tous les points de référence en tenant compte de la topologie (initialise reference_point_matrix).
* / ! \ La liste des * points de passage * , leur * matrice de distances * , ainsi que la liste des * points de référence * , DOIVENT Ê TRE INITIALISÉES avant l ' appel à cette fonction . Il faut donc appeler makeWaypointListFromFile ( ) et makeReferencePointListFromFile ( ) avant makeReferencePointDistances ( ) .
*/
void Server : : makeReferencePointDistances ( )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::makeReferencePointDistances() " < < endl ; fflush ( stdout ) ;
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
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
unsigned int nb_pts = reference_point_list . size ( ) ; // Nombre de points à traiter.
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
2008-08-07 15:44:54 +02:00
/* Construction de la matrice des distances */
reference_point_matrix = new float * [ nb_pts ] ; // Allocation de la première dimension.
for ( unsigned int i = 0 ; i < nb_pts ; i + + ) // Initialisation de la matrice :
{
reference_point_matrix [ i ] = new float [ nb_pts ] ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + ) // Initialisation des distances à -1
reference_point_matrix [ i ] [ k ] = - 1 ;
}
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
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Traitement des points de référence ( " < < nb_pts < < " )... " ;
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
# endif // DEBUG
2008-07-04 11:27:51 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " --> Liste des points de référence ( " < < nb_pts < < " ) : " < < endl ; fflush ( stdout ) ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG_2
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
2008-08-07 15:44:54 +02:00
/* Calcul des distances */
for ( unsigned int cur_idx = 0 ; cur_idx < nb_pts ; cur_idx + + )
{
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
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
if ( cur_idx % 100 = = 0 )
printf ( " \n %5d " , cur_idx ) ;
cout < < ' . ' ;
fflush ( stdout ) ;
2008-07-04 11:27:51 +02:00
# endif // DEBUG
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
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < ( Point ) reference_point_list [ cur_idx ] ;
cout < < " : " ;
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
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
reference_point_matrix [ cur_idx ] [ cur_idx ] = 0 ; // La distance du point à lui-même est nulle
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
2008-08-07 15:44:54 +02:00
for ( unsigned int k = 0 ; k < cur_idx ; k + + ) // Pour chacun des point précédent
{
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
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " / " < < ( Point ) reference_point_list [ k ] ;
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
# endif // DEBUG_2
2008-08-07 15:44:54 +02:00
float dist = distanceTopology ( ( Point ) reference_point_list [ cur_idx ] , ( Point ) reference_point_list [ k ] ) ; // On calcule la distance
reference_point_matrix [ cur_idx ] [ k ] = dist ; // et on l'insère dans le tableau,
reference_point_matrix [ k ] [ cur_idx ] = dist ; // dans les deux sens.
}
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
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " / " < < endl ;
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
# endif // DEBUG_2
2008-08-07 15:44:54 +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
2008-07-04 11:27:51 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < endl ;
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
# endif // DEBUG
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
/* Affichage de la matrice */
cout < < " --> Matrice des distances entre points de référence : \n \t \t | " ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
cout < < ' ' < < ( Point ) reference_point_list [ k ] < < " \t | " ;
cout < < endl ;
for ( unsigned int k = 0 ; k < nb_pts ; k + + )
{
cout < < ( Point ) reference_point_list [ k ] < < " \t | " ;
for ( unsigned int l = 0 ; l < nb_pts ; l + + )
cout < < ' \t ' < < reference_point_matrix [ k ] [ l ] < < " \t | " ;
cout < < endl ;
}
cout < < endl ;
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
# endif // DEBUG_2
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::makeReferencePointDistances() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-29 10:48:05 +02:00
}
2008-07-04 11:27:51 +02:00
/* Place dans "matrix" les distances entre les points de "l1" et de "l2", en les cherchant dans "reference_point_matrix".
*/
void Server : : selectDistances ( float_array * matrix , const vector < Point > & l1 , const vector < Point > & l2 ) const
{
2008-07-09 10:27:39 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::selectDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
matrix - > resize ( boost : : extents [ l1 . size ( ) ] [ l2 . size ( ) ] ) ;
2008-07-04 11:27:51 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < l1 . size ( ) ; i + + )
for ( unsigned int j = 0 ; j < l2 . size ( ) ; j + + )
( * matrix ) [ i ] [ j ] = reference_point_matrix [ pointIndex ( l1 [ i ] ) ] [ pointIndex ( l2 [ j ] ) ] ;
2008-07-09 10:27:39 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::selectDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
2008-07-04 11:27:51 +02:00
}
/* Calcule et place dans "matrix" les distances euclidiennes entre les points de "l1" et de "l2".
*/
void Server : : computeEuclideanDistances ( float_array * matrix , const vector < Point > & l1 , const vector < Point > & l2 ) const
{
2008-07-09 10:27:39 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::computeEuclideanDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
matrix - > resize ( boost : : extents [ l1 . size ( ) ] [ l2 . size ( ) ] ) ;
2008-07-04 11:27:51 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < l1 . size ( ) ; i + + )
for ( unsigned int j = 0 ; j < l2 . size ( ) ; j + + )
( * matrix ) [ i ] [ j ] = l1 [ i ] . distance ( l2 [ j ] ) ;
2008-07-09 10:27:39 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::computeEuclideanDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
}
/* Calcule et place dans "matrix" les distances euclidiennes entre les points de "l1" et de "l2".
*/
void Server : : computeTopologyDistances ( float_array * matrix , const vector < Point > & l1 , const vector < Point > & l2 )
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::computeTopologyDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
matrix - > resize ( boost : : extents [ l1 . size ( ) ] [ l2 . size ( ) ] ) ;
2008-07-09 10:27:39 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < l1 . size ( ) ; i + + )
for ( unsigned int j = 0 ; j < l2 . size ( ) ; j + + )
( * matrix ) [ i ] [ j ] = distanceTopology ( l1 [ i ] , l2 [ j ] ) ;
2008-07-09 10:27:39 +02:00
2008-07-18 18:35:47 +02:00
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " computeTopologyDistances() : matrice calculée ( " < < l1 . size ( ) < < " × " < < l2 . size ( ) < < " ) : " < < endl ;
for ( unsigned int i = 0 ; i < l1 . size ( ) ; i + + )
{
for ( unsigned int j = 0 ; j < l2 . size ( ) ; j + + )
cout < < ' [ ' < < ( * matrix ) [ i ] [ j ] < < ' ] ' ;
cout < < endl ;
}
2008-07-18 18:35:47 +02:00
# endif // DEBUG_2
2008-07-09 10:27:39 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::computeTopologyDistances() " < < endl ; fflush ( stdout ) ;
2008-07-09 10:27:39 +02:00
# endif // DEBUG_T
2008-07-04 11:27:51 +02:00
}
2008-05-05 13:59:55 +02:00
/* FONCTION POUR RÉTRO-COMPATIBILITÉ
* Affiche la liste des points de référence ( reference_point_list ) . */
2008-04-11 10:11:29 +02:00
void Server : : printReferencePointList ( )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::printReferencePointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
printPointList ( reference_point_list ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::printReferencePointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-05 13:59:55 +02:00
}
2008-04-15 12:19:15 +02:00
2008-05-05 13:59:55 +02:00
/* Affiche une liste de points (point_list). */
void Server : : printPointList ( vector < ReferencePoint > & point_list )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::printPointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < point_list . size ( ) ; i + + )
cout < < point_list [ i ] < < endl ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::printPointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-07-04 11:27:51 +02:00
void Server : : printAccessPointList ( ) const
2008-04-11 10:11:29 +02:00
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::printAccessPointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
cout < < access_point_list [ i ] < < endl ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::printAccessPointList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
void Server : : computeFriisFromRefList ( )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::computeFriisFromRefList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
vector < float > friis_idx_list ;
Point pt_coords , ap_coords ;
float ap_power , ap_gain , calib_gain = 2 , const_term , mes_power , friis_sum ;
unsigned int ap_freq ;
string ap_mac ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
ap_power = access_point_list [ i ] . getOutputPower ( ) ;
ap_coords = access_point_list [ i ] . getCoordinates ( ) ;
ap_freq = access_point_list [ i ] . getFrequency ( ) ;
ap_gain = access_point_list [ i ] . getAntennaGain ( ) ;
ap_mac = access_point_list [ i ] . getApAddr ( ) ;
/* Compute main general term, independant from scans */
const_term = calib_gain + ap_gain ;
const_term - = 20 * log10 ( 4 * M_PI ) ;
const_term + = 20 * log10 ( 300000000.0 / ap_freq ) + ap_power ;
/* Compute an index for each ref point. List stored in friis_idx_list */
for ( unsigned int j = 0 ; j < reference_point_list . size ( ) ; j + + )
{
pt_coords = reference_point_list [ j ] . getCoordinates ( ) ;
if ( reference_point_list [ i ] . getPowerForAp ( ap_mac , & mes_power ) )
friis_idx_list . push_back ( ( const_term - mes_power ) / ( 10 * log10 ( ap_coords . distance ( pt_coords ) ) ) ) ;
}
2008-05-05 13:59:55 +02:00
2008-08-07 15:44:54 +02:00
/* Now, compute avg value */
friis_sum = 0 ;
for ( unsigned int j = 0 ; j < friis_idx_list . size ( ) ; j + + )
friis_sum + = friis_idx_list [ j ] ;
access_point_list [ i ] . setFriisIndex ( friis_sum / friis_idx_list . size ( ) ) ;
2008-05-05 13:59:55 +02:00
2008-08-07 15:44:54 +02:00
cout < < access_point_list [ i ] . getApAddr ( ) < < " -> " < < ( friis_sum / friis_idx_list . size ( ) ) < < endl ;
2008-05-05 13:59:55 +02:00
2008-08-07 15:44:54 +02:00
friis_idx_list . clear ( ) ;
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::computeFriisFromRefList() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
}
2008-06-20 12:37:25 +02:00
2008-06-17 11:08:26 +02:00
/*Deuxième version de computeFriisFromRefList qui prend en entrée un point et retourne la liste d'index de friis équivalent*/
vector < float > Server : : computeFriisFromRefList ( const Point & p , const vector < Measurement > & m )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::computeFriisFromRefList(&Point, &vector<Measurement>) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
vector < float > friis_idx_list ;
Point pt_coords , ap_coords ;
float ap_power , ap_gain , calib_gain = 2 , const_term , mes_power /*, friis_sum*/ ;
unsigned int ap_freq ;
string ap_mac ;
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
{
cout < < " La distance entre le point d'accès: " < < access_point_list [ i ] . getCoordinates ( ) < < " et le point --> " < < p . distance ( access_point_list [ i ] . getCoordinates ( ) ) < < endl ;
}
/* Compute an index for each ref point. List stored in friis_idx_list */
/* Compute an index for Point p. List stored in friis_idx_list */
for ( unsigned int j = 0 ; j < reference_point_list . size ( ) ; j + + )
{
pt_coords = reference_point_list [ j ] . getCoordinates ( ) ;
if ( pt_coords = = p )
{
for ( unsigned int i = 0 ; i < m . size ( ) ; i + + )
{
if ( apExists ( m [ i ] . getMacAddr ( ) ) )
{
unsigned int ap_idx = apIndex ( m [ i ] . getMacAddr ( ) ) ;
ap_power = access_point_list [ ap_idx ] . getOutputPower ( ) ;
ap_coords = access_point_list [ ap_idx ] . getCoordinates ( ) ;
ap_freq = access_point_list [ ap_idx ] . getFrequency ( ) ;
ap_gain = access_point_list [ ap_idx ] . getAntennaGain ( ) ;
ap_mac = access_point_list [ ap_idx ] . getApAddr ( ) ;
/* Compute main general term, independant from scans */
const_term = calib_gain + ap_gain ;
const_term - = 20 * log10 ( 4 * M_PI ) ;
const_term + = 20 * log10 ( 300000000.0 / ap_freq ) + ap_power ;
if ( reference_point_list [ j ] . getPowerForAp ( ap_mac , & mes_power ) )
friis_idx_list . push_back ( ( const_term - mes_power ) / ( 10 * log10 ( ap_coords . distance ( pt_coords ) ) ) ) ;
else
friis_idx_list . push_back ( - 1 ) ;
cout < < " AP " < < m [ i ] . getMacAddr ( ) < < " has Friis index: " < < friis_idx_list [ i ] < < endl ;
}
}
break ;
}
2008-06-17 11:08:26 +02:00
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::computeFriisFromRefList(&Point, &vector<Measurement>) " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return friis_idx_list ;
2008-06-17 11:08:26 +02:00
}
2008-04-15 12:19:15 +02:00
2008-04-30 11:36:55 +02:00
2008-06-12 13:27:34 +02:00
/* Ajoute un client (ClientInfo) à la liste "client_list", et renvoie une référence sur l'élément ajouté. */
ClientInfo & Server : : createClient ( )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::createClient() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
client_list . push_back ( ClientInfo ( ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::createClient() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return client_list . back ( ) ;
2008-06-12 13:27:34 +02:00
}
/* Localise le client d'identifiant "client_id" en appliquant l'algorithme voulu. */
2008-06-20 12:37:25 +02:00
void Server : : monitorClient ( const unsigned int & client_id , const ALGORITHM & algo )
2008-04-11 10:11:29 +02:00
{
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::monitorClient() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
if ( VITERBI_N < 2 )
{
cerr < < " monitorClient() : N ne peut être inférieur à 2 ! " < < endl ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::monitorClient() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-08-07 15:44:54 +02:00
return ;
}
2008-04-11 10:11:29 +02:00
2008-08-07 15:44:54 +02:00
vector < Point >
& E_current = client_list [ client_id ] . getRef_viterbi_Ecurrent ( ) ,
& E_previous = client_list [ client_id ] . getRef_viterbi_Eprevious ( ) ;
Point position ;
float_array dst_matrix ;
vector < float > friisFromList ;
Point pointFastViterbi ;
Point Frbhmbasique ;
string filename = " trajet.txt " ;
ofstream fichier ;
2008-06-12 13:27:34 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
vector < ReferencePoint > peregrination_point_list ;
makePointListFromFile ( peregrination_point_list , DEFAULT_TRACKING_FILE , false ) ;
2008-06-12 13:27:34 +02:00
# endif // TEST
2008-06-11 17:04:50 +02:00
2008-05-07 10:59:06 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < reference_point_list . size ( ) < < " points de référence " ;
2008-05-26 15:15:33 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
cout < < " , " < < peregrination_point_list . size ( ) < < " points de pérégrination. " < < endl ;
2008-05-26 15:15:33 +02:00
# else // TEST
2008-08-07 15:44:54 +02:00
cout < < ' . ' < < endl ;
2008-05-26 15:15:33 +02:00
# endif // TEST
# endif // DEBUG
# ifdef DEBUG_2
2008-08-07 15:44:54 +02:00
cout < < " ***** Liste des points de référence : ***** " < < endl ;
printReferencePointList ( ) ;
2008-05-26 15:15:33 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
cout < < " ***** Liste des points de pérégrination : ***** " < < endl ;
printPointList ( peregrination_point_list ) ;
2008-05-26 15:15:33 +02:00
# endif // TEST
2008-08-07 15:44:54 +02:00
cout < < " ********************************* " < < endl ;
2008-05-26 15:15:33 +02:00
# endif // DEBUG_2
2008-05-05 13:59:55 +02:00
2008-05-26 15:15:33 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
unsigned int pt = 0 ;
while ( pt < peregrination_point_list . size ( ) )
2008-05-07 10:59:06 +02:00
# else // TEST
2008-08-07 15:44:54 +02:00
while ( true )
2008-05-07 10:59:06 +02:00
# endif // TEST
2008-08-07 15:44:54 +02:00
{
vector < Measurement > vm ;
2008-04-30 11:36:55 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
/* Get point measurements */
//vm.clear();
vm = peregrination_point_list [ pt ] . getMeasurementList ( ) ;
2008-06-12 13:27:34 +02:00
# else // TEST
2008-08-07 15:44:54 +02:00
vm = récupère_mesure ( ) ; // FIXME !
2008-05-07 10:59:06 +02:00
# endif // TEST
2008-04-11 10:11:29 +02:00
2008-08-07 15:44:54 +02:00
E_previous = E_current ;
E_current = getkClosestInSs ( vm , VITERBI_K ) ; // Création de l'ensemble des K points les plus proches dans l'espace des puissances.
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " Point courant : " < < peregrination_point_list [ pt ] ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-06-18 13:51:09 +02:00
2008-08-07 15:44:54 +02:00
switch ( algo )
{
case ALGO_VLI : /* Application de l'algorithme Viterbi */
computeEuclideanDistances ( & dst_matrix , E_previous , E_current ) ; // On précalcule les distances entre les points de E_previous et E_current.
position = fastViterbiLike ( client_id , dst_matrix ) ;
break ;
case ALGO_BASIC_FRBHM : /* Application de l'algorithme FRBHM basique */
cout < < " -------FRBHM BASIQUE--------- " < < endl ;
//computeFriisFromRefList() ;
selectDistances ( & dst_matrix , E_previous , E_current ) ; // On récupère une sous-matrice de reference_point_matrix avec les distances entre les points de E_previous et E_current.
position = fastViterbiLike ( client_id , dst_matrix ) ;
cout < < " Position: " < < position < < endl ;
friisFromList = computeFriisFromRefList ( position , vm ) ;
//fbcm_friis(vm, friisFromList) ;
//Just to see
cout < < " --------------------------- " < < endl ;
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
cout < < " Dist between ap " < < access_point_list [ i ] . getCoordinates ( ) < < " and true point = " < < access_point_list [ i ] . getCoordinates ( ) . distance ( peregrination_point_list [ pt ] . getCoordinates ( ) ) < < endl ;
//end of 'just to see'
Frbhmbasique = fbcm_friis ( vm , friisFromList , position . getZ ( ) ) ;
cout < < " Point selectionné final: " < < Frbhmbasique < < endl ;
fichier . open ( filename . c_str ( ) , std : : ios : : app ) ;
if ( ! fichier ) {
cerr < < " Erreur de creation du fichier " < < endl ;
exit ( 1 ) ;
}
fichier < < Frbhmbasique < < std : : endl ;
fichier . close ( ) ;
break ;
case ALGO_CONTINU_FRBHM : /* Application de l'algorithme FRBHM continu */
cout < < " --------FRBHM CONTINU------------ " < < endl ;
//computeFriisFromRefList();
//Just to see
cout < < " --------------------------- " < < endl ;
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
cout < < " Dist between ap " < < access_point_list [ i ] . getCoordinates ( ) < < " and true point " < < peregrination_point_list [ pt ] . getCoordinates ( ) < < " = " < < access_point_list [ i ] . getCoordinates ( ) . distance ( peregrination_point_list [ pt ] . getCoordinates ( ) ) < < endl ;
//end of 'just to see'
for ( unsigned int i = 0 ; i < E_current . size ( ) ; i + + )
{
friisFromList = computeFriisFromRefList ( E_current [ i ] , vm ) ;
E_current [ i ] = fbcm_friis ( vm , friisFromList , E_current [ i ] . getZ ( ) ) ;
}
computeTopologyDistances ( & dst_matrix , E_previous , E_current ) ; // On calcule les distances entre les points de E_previous et E_current, en tenant compte de la topologie).
pointFastViterbi = fastViterbiLike ( client_id , dst_matrix ) ;
fichier . open ( filename . c_str ( ) , std : : ios : : app ) ;
cout < < " Point selectionné: " < < pointFastViterbi < < endl ;
if ( ! fichier ) {
cerr < < " Erreur de creation du fichier " < < endl ;
exit ( 1 ) ;
}
fichier < < pointFastViterbi < < endl ;
fichier . close ( ) ;
break ;
default :
cerr < < " Erreur ! Algorithme inconnu. " < < endl ;
}
2008-06-12 13:27:34 +02:00
# ifdef TEST
2008-08-07 15:44:54 +02:00
pt + + ;
2008-06-12 13:27:34 +02:00
# endif // TEST
2008-08-07 15:44:54 +02:00
}
2008-06-12 13:27:34 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::monitorClient() " < < endl ; fflush ( stdout ) ;
2008-06-12 13:27:34 +02:00
# endif // DEBUG_T
}
/*
* Computes new cumulative distances for the viterbi instance of the client nb " client_id " .
* Returns the solution ( Point ) of the last ended viterbi .
* Distances are grouped by line corresponding to an instance .
*/
2008-07-04 11:27:51 +02:00
Point Server : : fastViterbiLike ( const unsigned int & client_id , const float_array & distance_matrix )
2008-06-12 13:27:34 +02:00
{
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //--> Server::fastViterbiLike() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
float_array & V = client_list [ client_id ] . getRef_viterbi_V ( ) ;
vector < Point > & E_current = client_list [ client_id ] . getRef_viterbi_Ecurrent ( ) ;
unsigned int & i = client_list [ client_id ] . getRef_viterbi_iteration ( ) ;
int N = VITERBI_N , K = VITERBI_K ;
unsigned int V0_min_k = 0 ; // Indice du point sélectionné à chaque itération
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
if ( i > 1 ) // Si on n'est plus à la première itération
2008-06-12 13:27:34 +02:00
{
2008-08-07 15:44:54 +02:00
/* Recalcul des plus courtes distances */
for ( float_index n = N - 1 - i ; n < N - 2 ; n + + ) // Pour chaque historique existant (sauf le dernier),
for ( float_index k = 0 ; k < K ; k + + ) // pour chaque point de l'historique,
{ // on met à jour le chemin minimum entre l'historique précédent et le point :
V [ n ] [ k ] = V [ n + 1 ] [ 0 ] + distance_matrix [ 0 ] [ k ] ;
for ( float_index l = 1 ; l < K ; l + + )
{
float f = V [ n + 1 ] [ l ] + distance_matrix [ l ] [ k ] ;
if ( f < V [ n ] [ k ] )
V [ n ] [ k ] = f ;
}
}
/* Traitement du dernier historique */
for ( float_index k = 0 ; k < K ; k + + ) // Pour chaque point,
{ // on récupère le chemin minimum entre l'historique précédent et le point :
V [ N - 2 ] [ k ] = distance_matrix [ 0 ] [ k ] ;
for ( float_index l = 1 ; l < K ; l + + )
{
float f = distance_matrix [ l ] [ k ] ;
if ( f < V [ N - 2 ] [ k ] )
V [ N - 2 ] [ k ] = f ;
}
}
/* Choix du point à renvoyer */
V0_min_k = 0 ; // Indice du point correspondant au V0 minimal. Si le tableau n'est pas plein, la plus petite valeur a l'indice 0 (car getkClosestInSs() renvoit un résultat trié).
if ( N - 1 - i = = 0 )
{
2008-05-26 15:15:33 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
float V0_min = V [ 0 ] [ 0 ] ;
cout < < " V[0][0]= " < < V [ 0 ] [ 0 ] < < " ; V0_min= " < < V0_min < < " ; V0_min_k= " < < V0_min_k < < " -- " ;
2008-05-26 15:15:33 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
for ( float_index k = 1 ; k < K ; k + + )
{
if ( V [ 0 ] [ k ] < V0_min )
{
V0_min_k = k ;
2008-05-26 15:15:33 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
V0_min = V [ 0 ] [ k ] ;
2008-05-26 15:15:33 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-05-26 15:15:33 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " V[0][ " < < k < < " ]= " < < V [ 0 ] [ k ] < < " ; V0_min= " < < V0_min < < " ; V0_min_k= " < < V0_min_k < < " -- " ;
2008-05-26 15:15:33 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-06-12 13:27:34 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " V0_min = " < < V0_min < < " ; V0_min_k= " < < V0_min_k < < endl ;
2008-06-12 13:27:34 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
}
2008-04-30 11:36:55 +02:00
}
2008-04-11 10:11:29 +02:00
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " V : " < < endl ;
for ( float_index n = 0 ; n < N - 1 ; n + + )
{
for ( float_index k = 0 ; k < K ; k + + )
cout < < " [ " < < V [ n ] [ k ] < < " ] " ;
cout < < endl ;
}
cout < < " Point sélectionné : " < < E_current [ V0_min_k ] < < endl ;
cout < < " -------------------------- " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-08-07 15:44:54 +02:00
if ( i < N - 1 )
i + + ;
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
2008-08-07 15:44:54 +02:00
cout < < " //<-- Server::fastViterbiLike() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-06-12 13:27:34 +02:00
2008-08-07 15:44:54 +02:00
return E_current [ V0_min_k ] ;
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* For experimentation purpose only */
2008-08-07 15:44:54 +02:00
void Server : : radar_exp ( const string & outfile , const string & testfile )
2008-04-11 10:11:29 +02:00
{
2008-08-07 15:44:54 +02:00
string fname ;
ofstream logfile ;
Point solution , solution_kw , ref_coords ;
unsigned int i ;
vector < Measurement > vm ;
2008-04-11 10:11:29 +02:00
2008-08-07 15:44:54 +02:00
computeFriisFromRefList ( ) ;
2008-07-15 18:06:10 +02:00
2008-08-07 15:44:54 +02:00
if ( client_list . empty ( ) )
{
2008-07-15 18:06:10 +02:00
# ifdef DEBUG
2008-08-07 15:44:54 +02:00
cout < < " radar_exp() : création d'un client. " < < endl ;
2008-07-15 18:06:10 +02:00
# endif // DEBUG
2008-08-07 15:44:54 +02:00
createClient ( ) ;
}
logfile . open ( outfile . c_str ( ) ) ;
if ( logfile . fail ( ) )
{
cerr < < " Error opening output file « " < < logfile < < " » ! " < < endl ;
return ;
}
/* Column names */
logfile < < " Coordinates \
2008-07-15 18:06:10 +02:00
\ tInterlink \ t ( Error ) \
\ tRADAR \ t ( Error ) \
\ tFBCM \ t ( Error ) \
2008-08-18 18:19:02 +02:00
\ tFRBHM \ t ( Error ) " << endl ;
2008-04-15 12:19:15 +02:00
2008-08-07 15:44:54 +02:00
cout < < reference_point_list . size ( ) < < " reference points. " < < endl ;
2008-07-23 18:11:43 +02:00
2008-08-07 15:44:54 +02:00
vector < ReferencePoint > test_point_list ;
makePointListFromFile ( test_point_list , DEFAULT_REF_POINT_FILE_1M , true ) ;
cout < < test_point_list . size ( ) < < " reference points to test. " < < endl ;
2008-08-18 18:19:02 +02:00
float radar_error = 0 , in_error = 0 , fbcm_error = 0 , frbhm_error = 0 ;
2008-07-15 18:06:10 +02:00
2008-08-07 15:44:54 +02:00
for ( i = 0 ; i < test_point_list . size ( ) ; i + + )
{
/* Get point measurements */
vm = test_point_list [ i ] . getMeasurementList ( ) ;
cout < < vm . size ( ) < < " measurements: " < < endl ;
for ( unsigned int prout = 0 ; prout < vm . size ( ) ; prout + + )
cout < < vm [ prout ] < < endl ;
ref_coords = test_point_list [ i ] . getCoordinates ( ) ;
/* Print point coordinates */
logfile < < ref_coords < < " \t " ;
/* Interlink Networks */
solution = interlink ( vm , 0 ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
in_error + = solution . distance ( ref_coords ) ;
2008-08-07 15:44:54 +02:00
/* RADAR */
solution = getkClosestInSs ( vm , 1 , & ref_coords ) [ 0 ] ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
radar_error + = solution . distance ( ref_coords ) ;
2008-08-07 15:44:54 +02:00
/* FBCM */
solution = fbcm ( vm , 0 ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
fbcm_error + = solution . distance ( ref_coords ) ;
2008-08-07 15:44:54 +02:00
/* 1-NSS + FBCM */
solution = getkClosestInSs ( vm , 1 , & ref_coords ) [ 0 ] ;
solution = fbcm_friis ( vm , computeFriisFromRefList ( solution , vm ) , solution . getZ ( ) ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
frbhm_error + = solution . distance ( ref_coords ) ;
2008-08-07 15:44:54 +02:00
2008-08-18 18:19:02 +02:00
/* 2-NSS
2008-08-07 15:44:54 +02:00
solution = getkWeightedInSs ( vm , 2 , & ref_coords ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
/* 3-NSS
2008-08-07 15:44:54 +02:00
solution = getkWeightedInSs ( vm , 3 , & ref_coords ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-08-18 18:19:02 +02:00
/* 5-NSS
2008-08-07 15:44:54 +02:00
solution = getkWeightedInSs ( vm , 5 , & ref_coords ) ;
2008-08-18 18:19:02 +02:00
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ; */
2008-08-07 15:44:54 +02:00
logfile < < endl ;
vm . clear ( ) ;
}
/* Mean values formulas names */
2008-08-18 18:19:02 +02:00
float nb = ( float ) test_point_list . size ( ) ;
logfile < < " \t \t " < < ( in_error / nb ) < < " \t \t " < < ( radar_error / nb ) < < " \t \t " < < ( fbcm_error / nb ) < < " \t \t " < < ( frbhm_error / nb ) < < endl ;
2008-08-07 15:44:54 +02:00
logfile . close ( ) ;
2008-04-11 10:11:29 +02:00
}