2008-04-11 10:11:29 +02:00
# include "server.hh"
2008-04-30 11:36:55 +02:00
/******* Misc. very usefull functions *******/
2008-05-29 10:48:05 +02:00
/* Retourne la position du Point "p" dans le tableau "tab" de taille "size", ou -1 en cas d'échec. */
inline int point_tab_idx ( const Point * tab , unsigned int & size , const Point & p )
{
for ( unsigned int i = 0 ; i < size ; i + + )
if ( tab [ i ] = = p )
return i ;
return - 1 ;
}
2008-04-15 12:19:15 +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
/* Retourne la position du Point "p" dans le vector "v", ou -1 en cas d'échec. */
inline int point_vector_idx ( const vector < Point > & v , const Point & p )
{
for ( unsigned int i = 0 ; i < v . size ( ) ; i + + )
if ( v [ i ] = = p )
return i ;
return - 1 ;
}
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
{
vector < string > vs ;
string tmp ;
unsigned int i ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < input . size ( ) ; i + + )
if ( input [ i ] = = sep )
2008-04-11 10:11:29 +02:00
{
vs . push_back ( tmp ) ;
tmp . clear ( ) ;
}
else
{
tmp . push_back ( input [ i ] ) ;
}
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
//Last entry, did not encounter a separator.
vs . push_back ( tmp ) ;
tmp . clear ( ) ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
return vs ;
}
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
{
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
int tmp ;
2008-04-15 12:19:15 +02:00
iss > > tmp ;
2008-04-11 10:11:29 +02:00
return tmp ;
}
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
{
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
unsigned int tmp ;
2008-04-15 12:19:15 +02:00
iss > > tmp ;
2008-04-11 10:11:29 +02:00
return tmp ;
}
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
{
istringstream iss ( nb ) ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
float tmp ;
2008-04-15 12:19:15 +02:00
iss > > tmp ;
2008-04-11 10:11:29 +02:00
return tmp ;
}
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 )
{
unsigned int ptr = 0 ;
vector < int > ret ;
string tmp_field ;
2008-04-15 12:19:15 +02:00
if ( buff [ buff . size ( ) - 1 ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
buff . push_back ( ' ; ' ) ;
2008-04-15 12:19:15 +02:00
while ( ptr < buff . size ( ) )
2008-04-11 10:11:29 +02:00
{
2008-04-15 12:19:15 +02:00
if ( buff [ ptr ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
tmp_field . push_back ( buff [ ptr ] ) ;
else
{
ret . push_back ( string2int ( tmp_field ) ) ;
tmp_field . clear ( ) ;
}
ptr + + ;
}
return ret ;
}
2008-04-30 11:36:55 +02:00
inline vector < string > extractReferencePointInfoFromBuffer ( const string & buffer_in )
2008-04-11 10:11:29 +02:00
{
unsigned int i = 0 ;
string tmp_field ;
vector < string > ret ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Extract coordinates */
/* x */
2008-04-15 12:19:15 +02:00
while ( buffer_in [ i ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
{
tmp_field . push_back ( buffer_in [ i ] ) ;
i + + ;
}
ret . push_back ( tmp_field ) ;
tmp_field . clear ( ) ;
2008-04-30 11:36:55 +02:00
i + + ; // go after the ';'
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* y */
2008-04-15 12:19:15 +02:00
while ( buffer_in [ i ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
{
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.
/* 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-04-11 10:11:29 +02:00
/* Extract direction (not used now) */
2008-04-15 12:19:15 +02:00
while ( buffer_in [ i ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
{
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-04-11 10:11:29 +02:00
/* Extract mac address */
2008-04-15 12:19:15 +02:00
while ( buffer_in [ i ] ! = ' ; ' )
2008-04-11 10:11:29 +02:00
{
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-11 10:11:29 +02:00
/* Extract scan list */
2008-04-15 12:19:15 +02:00
while ( i < buffer_in . size ( ) )
2008-04-11 10:11:29 +02:00
{
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-04-30 11:36:55 +02:00
while ( i < = buffer_in . size ( ) )
{
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,
{
# ifdef DEBUG_2
cout < < " Ajout de la valeur lue : " < < tmp_field < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-04-30 11:36:55 +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.
i + + ;
}
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Return the vector with each data */
return ret ;
}
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-04-30 11:36:55 +02:00
Server : : Server ( 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
cout < < " //--> Server::Server() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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-04-11 10:11:29 +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-04-11 10:11:29 +02:00
/* Bind */
bind ( sockListen , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ) ) ;
2008-04-30 11:36:55 +02:00
2008-05-29 10:48:05 +02:00
makeReferencePointListFromFile ( DEFAULT_REF_POINT_FILE ) ; // Initialisation de "reference_point_list".
makeApListFromFile ( DEFAULT_AP_FILE ) ; // Initialisation de "access_point_list".
makeTopologyFromFile ( DEFAULT_TOPOLOGY_FILE ) ; // Initialisation de "area_list".
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
makeWaypointListFromFile ( DEFAULT_WAYPOINT_FILE ) ; // Initialisation de "waypoint_list" et "waypoint_matrix".
makeReferencePointDistances ( ) ; // Initialisation de "reference_point_matrix".
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::Server() " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::~Server() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
close ( sockListen ) ;
close ( sockSend ) ;
2008-06-11 17:04:50 +02:00
reference_point_list . clear ( ) ;
access_point_list . clear ( ) ;
client_list . clear ( ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::~Server() " < < endl ; fflush ( stdout ) ;
# 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
{
/* Do not forget to implement later: usefull for a demo */
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
int Server : : receive_data ( )
{
/* Do not forget to implement later: usefull for a demo */
return 0 ;
}
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
cout < < " //--> Server::inWhichAreas() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
map < string , Area > areas ;
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 ) ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::inWhichAreas() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return areas ;
}
/* 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
cout < < " //--> Server::areaConnection(Area&, Area&) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
vector < Point > points ;
for ( unsigned int i = 0 ; i < reference_point_list . size ( ) ; i + + )
{
map < string , Area > areas ( inWhichAreas ( reference_point_list [ i ] ) ) ;
if ( areas . find ( z1 . getName ( ) ) ! = areas . end ( ) & & areas . find ( z2 . getName ( ) ) ! = areas . end ( ) )
points . push_back ( reference_point_list [ i ] ) ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::areaConnection(Area&, Area&) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return points ;
}
/* 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
cout < < " //--> Server::areaConnection(Area&) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
vector < Point > points ;
for ( unsigned int i = 0 ; i < reference_point_list . size ( ) ; i + + )
{
map < string , Area > areas ( inWhichAreas ( reference_point_list [ i ] ) ) ;
if ( areas . find ( z . getName ( ) ) ! = areas . end ( ) )
points . push_back ( reference_point_list [ i ] ) ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::areaConnection(Area&) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return points ;
}
/* 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
cout < < " //--> Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
map < string , Area >
zones1 ( inWhichAreas ( p1 ) ) ,
zones2 ( inWhichAreas ( p2 ) ) ;
if ( zones1 . size ( ) = = 0 | | zones2 . size ( ) = = 0 ) // Si aucune zone ne contient p1 ou p2,
{
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return - 1 ; // on quitte.
}
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 ;
/* *** Cas de la même zone *** */
if ( z1 = = z2 ) // Si les points sont dans la même zone,
{
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return p1 . distance ( p2 ) ; // la distance entre eux est la distance euclidienne.
}
/* *** Cas de deux zones voisines *** */
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.
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 ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return dist ;
}
/* *** Les points sont dans des zones non-voisines *** */
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);
if ( wp_z1 . size ( ) = = 0 | | wp_z2 . size ( ) = = 0 ) // Si l'une des deux zones ne comporte aucun point de passage,
{
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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 = point_vector_idx ( waypoint_list , wp_z1 [ i1 ] ) ;
for ( i2 = 0 ; i2 < wp_z2 . size ( ) ; i2 + + )
{
wp_z2_idx = point_vector_idx ( waypoint_list , wp_z2 [ i2 ] ) ;
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,
{
# ifdef DEBUG_T
cout < < " //<-- Server::distanceTopology() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return - 1 ; // on quitte.
}
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 = point_vector_idx ( 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 ;
}
/* 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 = point_vector_idx ( waypoint_list , wp_z1 [ i ] ) ;
wp_z2_idx = point_vector_idx ( 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 ;
}
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-04-30 11:36:55 +02:00
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
cout < < " //--> Server::pointExists(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
bool ret = pointExists ( reference_point_list , Point ( x , y , z ) ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointExists(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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 . */
bool Server : : pointExists ( const Point & p ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::pointExists(&Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
bool ret = pointExists ( reference_point_list , p ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointExists(&Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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. */
bool Server : : pointExists ( const vector < ReferencePoint > & point_list , const float & x , const float & y , const float & z ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::pointExists(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
bool ret = pointExists ( point_list , Point ( x , y , z ) ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointExists(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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. */
bool Server : : pointExists ( const vector < ReferencePoint > & point_list , const Point & p ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::pointExists(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
unsigned int i ;
2008-04-15 12:19:15 +02:00
2008-05-07 10:59:06 +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
cout < < " //<-- Server::pointExists(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return true ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::pointExists(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
return false ;
}
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
/* Do not forget to call pointExists() before this one */
2008-04-30 11:36:55 +02:00
unsigned 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
cout < < " //--> Server::pointIndex(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
unsigned int ret = pointIndex ( reference_point_list , Point ( x , y , z ) ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointIndex(&float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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
/* Do not forget to call pointExists() before this one */
unsigned int Server : : pointIndex ( const Point & p ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::pointIndex(&Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
unsigned int ret = pointIndex ( reference_point_list , p ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointIndex(&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
2008-05-07 10:59:06 +02:00
unsigned int Server : : pointIndex ( const vector < ReferencePoint > & point_list , const float & x , const float & y , const float & z ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::pointIndex(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
unsigned int ret = pointIndex ( point_list , Point ( x , y , z ) ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &float, &float, &float) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return ret ;
2008-05-07 10:59:06 +02:00
}
unsigned 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
cout < < " //--> Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
unsigned int i ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
if ( p = = reference_point_list [ i ] . getCoordinates ( ) )
2008-06-20 12:37:25 +02:00
{
# ifdef DEBUG_T
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return i ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::pointIndex(&vector<ReferencePoint>, &Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-15 12:19:15 +02:00
2008-05-07 10:59:06 +02:00
return 0 ; // Should never happen
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
cout < < " //--> Server::apExists() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-17 11:08:26 +02:00
string str ;
2008-06-20 12:37:25 +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 ] ) ;
for ( i = 0 ; i < access_point_list . size ( ) ; i + + )
if ( str = = ap_addr )
{
# ifdef DEBUG_T
cout < < " //<-- Server::apExists() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return true ;
}
}
# ifdef DEBUG_T
cout < < " //<-- Server::apExists() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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
cout < < " //--> Server::apIndex() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
unsigned int i ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < access_point_list . size ( ) ; i + + )
if ( access_point_list [ i ] . getApAddr ( ) = = ap_addr )
2008-06-20 12:37:25 +02:00
{
# ifdef DEBUG_T
cout < < " //<-- Server::apIndex() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
return i ;
}
# ifdef DEBUG_T
cout < < " //<-- Server::apIndex() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-15 12:19:15 +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
cout < < " //--> Server::getkClosestInSs(&vector<Measurement>, &unsigned int) " < < endl ;
cout < < " //<-- Server::getkClosestInSs(&vector<Measurement>, &unsigned int) " < < endl ;
fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-30 11:36:55 +02:00
return getkClosestInSs ( m , k , NULL ) ;
}
/* 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
cout < < " //--> Server::getkClosestInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
2008-04-30 11:36:55 +02:00
if ( point_ignored = = NULL | | ( reference_point_list [ i ] . getCoordinates ( ) ! = * point_ignored ) )
2008-04-11 10:11:29 +02:00
{
tmp_distance = reference_point_list [ i ] . getSsSquareDistance ( m ) ;
2008-05-07 14:25:51 +02:00
# ifdef DEBUG_2
cout < < tmp_distance < < " " ;
# endif // DEBUG_2
2008-04-11 10:11:29 +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 ( ) ) ;
2008-05-05 13:59:55 +02:00
dist_max = ( dist_max < tmp_distance ) ? tmp_distance : dist_max ;
2008-04-11 10:11:29 +02:00
}
else
{
/* if tmp_dst < dist_max, should add it and remove previous greatest dist. */
if ( dist_max > tmp_distance )
{
/* remove old max */
2008-04-15 12:19:15 +02:00
for ( j = 0 ; j < distances_vector . size ( ) ; j + + )
if ( distances_vector [ j ] = = dist_max )
2008-04-11 10:11:29 +02:00
{
2008-05-07 14:25:51 +02:00
distances_vector [ j ] = tmp_distance ;
2008-05-07 13:59:54 +02:00
points_vector [ j ] = reference_point_list [ i ] . getCoordinates ( ) ;
2008-04-11 10:11:29 +02:00
break ;
}
2008-05-07 14:15:42 +02:00
/* 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 ] ;
2008-04-11 10:11:29 +02:00
}
/* Else nothing needs to be done */
}
}
2008-05-07 14:25:51 +02:00
# ifdef DEBUG_2
cout < < endl ;
# endif // DEBUG_2
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Sorts the vector */
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < distances_vector . size ( ) - 1 ; i + + )
2008-04-11 10:11:29 +02:00
{
tmp_min = distances_vector [ i ] ;
min_idx = i ;
2008-04-15 12:19:15 +02:00
for ( j = i + 1 ; j < distances_vector . size ( ) ; j + + )
if ( tmp_min > distances_vector [ j ] )
2008-04-11 10:11:29 +02:00
{
tmp_min = distances_vector [ j ] ;
min_idx = j ;
}
2008-04-15 12:19:15 +02:00
if ( min_idx ! = i )
2008-04-11 10:11:29 +02:00
{
/* Swap points */
tmp_pt = points_vector [ i ] ;
points_vector [ i ] = points_vector [ min_idx ] ;
points_vector [ min_idx ] = tmp_pt ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Swap distances */
distances_vector [ min_idx ] = distances_vector [ i ] ;
distances_vector [ i ] = tmp_min ;
}
}
2008-04-15 12:19:15 +02:00
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
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 ( ) - 1 ; 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
cout < < " //<-- Server::getkClosestInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
return points_vector ;
}
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
cout < < " //--> Server::getkWeightedInSs(&vector<Measurement>, &unsigned int) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
Point ret = getkWeightedInSs ( m , k , NULL ) ;
# ifdef DEBUG_T
cout < < " //<-- Server::getkWeightedInSs(&vector<Measurement>, &unsigned int) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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
cout < < " //--> Server::getkWeightedInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
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 ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
2008-04-30 11:36:55 +02:00
if ( point_ignored = = NULL | | ( reference_point_list [ i ] . getCoordinates ( ) ! = * point_ignored ) )
2008-04-11 10:11:29 +02:00
{
tmp_distance = reference_point_list [ i ] . getSsSquareDistance ( m ) ;
/* if not k points, add it */
2008-04-15 12:19:15 +02:00
if ( distances_vector . size ( ) < k )
2008-04-11 10:11:29 +02:00
{
distances_vector . push_back ( tmp_distance ) ;
points_vector . push_back ( reference_point_list [ i ] . getCoordinates ( ) ) ;
2008-04-15 12:19:15 +02:00
dist_max = ( dist_max > tmp_distance ) ? tmp_distance : dist_max ;
2008-04-11 10:11:29 +02:00
}
else
{
/* if tmp_dst < dist_max, should add it and remove previous greatest dist. */
2008-04-15 12:19:15 +02:00
if ( dist_max > tmp_distance )
2008-04-11 10:11:29 +02:00
{
/* remove old max */
2008-04-15 12:19:15 +02:00
for ( j = 0 ; j < distances_vector . size ( ) ; j + + )
2008-04-11 10:11:29 +02:00
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 */
}
}
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < distances_vector . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
total + = distances_vector [ i ] ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < distances_vector . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
{
x + = points_vector [ i ] . getX ( ) * distances_vector [ i ] / total ;
y + = points_vector [ i ] . getY ( ) * distances_vector [ i ] / total ;
z + = points_vector [ i ] . getZ ( ) * distances_vector [ i ] / total ;
}
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
ret . setX ( x ) ;
ret . setY ( y ) ;
ret . setZ ( z ) ;
2008-04-15 12:19:15 +02:00
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::getkWeightedInSs(&vector<Measurement>, &unsigned int, *Point) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
return ret ;
}
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
cout < < " //--> Server::kPointsAverage() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
unsigned int i ;
float x = 0 , y = 0 , z = 0 ;
Point p ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < vp . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
{
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
cout < < " //<-- Server::kPointsAverage() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
return p ;
}
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
cout < < " //--> Server::fbcm() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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 ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
i = 0 ;
//cout << "FBCM: ";
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < m . size ( ) ; i + + )
if ( apExists ( m [ i ] . getMacAddr ( ) ) )
2008-04-11 10:11:29 +02:00
{
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 ;
2008-04-15 12:19:15 +02:00
constant_term + = 20 * log10 ( ( 300000000.0 / ( float ) access_point_list [ ap_idx ] . getFrequency ( ) ) / ( 4 * M_PI ) ) ;
2008-04-11 10:11:29 +02:00
//end of expr. should be: client_list[client_idx].getAntennaGain() instead of 2.
2008-04-15 12:19:15 +02:00
//cout << "20log(" << (300000000.0 / (float) access_point_list[ap_idx].getFrequency()) / (4*M_PI) << ") = ";
2008-04-11 10:11:29 +02:00
//cout << constant_term << " ";
dist_vect . push_back ( pow ( 10 , ( constant_term - m [ i ] . getAverage ( ) ) / ( 10 * access_point_list [ ap_idx ] . getFriisIndex ( ) ) ) ) ;
//cout << endl;
}
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Then: min-max */
minmax_res = 1000000 ;
2008-04-15 12:19:15 +02:00
for ( x = MINMAX_X_START ; x < MINMAX_X_STOP ; x + = MINMAX_STEP )
for ( y = MINMAX_Y_START ; y < MINMAX_Y_STOP ; y + = MINMAX_STEP )
2008-04-11 10:11:29 +02:00
{
minmax_max = 0 ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < centres . size ( ) ; i + + )
if ( ( centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ) > minmax_max )
minmax_max = centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
2008-04-11 10:11:29 +02:00
{
ret . setX ( x ) ;
ret . setY ( y ) ;
minmax_res = minmax_max ;
}
}
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Clear all vectors */
addr . clear ( ) ;
dist_vect . clear ( ) ;
centres . clear ( ) ;
2008-04-15 12:19:15 +02:00
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::fbcm() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +02:00
/* Return position */
return ret ;
}
2008-06-17 11:08:26 +02:00
/*second version of fbcm with as parameter vector<Measurement> &m and a list of friis index*/
Point Server : : fbcm_friis ( const vector < Measurement > & m , const vector < float > friis_idx_list ) const
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::fbcm_friis() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-17 11:08:26 +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 ;
i = 0 ;
//cout << "FBCM: ";
for ( i = 0 ; i < m . size ( ) ; i + + ) { cout < < " m[i].getMacAddr() " < < m [ i ] . getMacAddr ( ) < < endl ;
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 ) ) ;
for ( j = 0 ; j < friis_idx_list . size ( ) ; j + + )
{
dist_vect . push_back ( pow ( 10 , ( constant_term - m [ i ] . getAverage ( ) ) / ( 10 * friis_idx_list [ j ] ) ) ) ;
}
}
}
/* 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 ( ( centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ) > minmax_max )
minmax_max = centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
{
ret . setX ( x ) ;
ret . setY ( y ) ;
minmax_res = minmax_max ;
}
}
/* Clear all vectors */
addr . clear ( ) ;
dist_vect . clear ( ) ;
centres . clear ( ) ;
2008-06-20 12:37:25 +02:00
cout < < " RESULTAT DU FRBHM ---> " < < ret < < endl ;
# ifdef DEBUG_T
cout < < " //<-- Server::fbcm_friis() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-17 11:08:26 +02:00
/* Return position */
return ret ;
}
2008-04-30 11:36:55 +02:00
Point Server : : interlink ( 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
cout < < " //--> Server::interlink() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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 ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
i = 0 ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < m . size ( ) ; i + + )
if ( apExists ( m [ i ] . getMacAddr ( ) ) )
2008-04-11 10:11:29 +02:00
{
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 ( ) ;
2008-04-15 12:19:15 +02:00
constant_term + = 20 * log10 ( ( 300000000.0 / ( float ) access_point_list [ ap_idx ] . getFrequency ( ) ) / ( 4 * M_PI ) ) + 2 ;
2008-04-11 10:11:29 +02:00
//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 ) ) ;
2008-04-15 12:19:15 +02:00
}
2008-04-11 10:11:29 +02:00
/* Then: min-max */
minmax_res = 1000000 ;
2008-04-15 12:19:15 +02:00
for ( x = MINMAX_X_START ; x < MINMAX_X_STOP ; x + = MINMAX_STEP )
for ( y = MINMAX_Y_START ; y < MINMAX_Y_STOP ; y + = MINMAX_STEP )
2008-04-11 10:11:29 +02:00
{
minmax_max = 0 ;
2008-04-15 12:19:15 +02:00
for ( i = 0 ; i < centres . size ( ) ; i + + )
if ( ( centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ) > minmax_max )
minmax_max = centres [ i ] . squareDistance ( x , y , 3 ) - ( dist_vect [ i ] * dist_vect [ i ] ) ;
if ( minmax_max < minmax_res )
2008-04-11 10:11:29 +02:00
{
ret . setX ( x ) ;
ret . setY ( y ) ;
minmax_res = minmax_max ;
}
}
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Clear all vectors */
addr . clear ( ) ;
dist_vect . clear ( ) ;
centres . clear ( ) ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Return position */
return ret ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::interlink() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
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
cout < < " //--> Server::makePointListFromFile(&string) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-07 10:59:06 +02:00
makePointListFromFile ( reference_point_list , filename , true ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::makePointListFromFile(&string) " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::makePointListFromFile(&vector<ReferencePoint>, &string) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-07 10:59:06 +02:00
makePointListFromFile ( dest_point_list , filename , true ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::makePointListFromFile(&vector<ReferencePoint>, &string) " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::makePointListFromFile(&vector<ReferencePoint>, &string, bool) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-05 13:59:55 +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.
2008-04-11 10:11:29 +02:00
ReferencePoint rp ;
Point tmp_point ;
2008-05-05 13:59:55 +02:00
float x , y , z ; // Coordonnées des points.
2008-05-07 10:59:06 +02:00
unsigned int pt_idx = 0 ; // Position du point lu dans la liste.
2008-05-05 13:59:55 +02:00
vector < string > infos ; // Liste des informations lues dans une ligne du fichier.
2008-04-15 12:19:15 +02:00
input_file . open ( filename . c_str ( ) ) ;
2008-04-30 11:36:55 +02:00
2008-04-15 12:19:15 +02:00
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
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-04-15 12:19:15 +02:00
while ( ! input_file . eof ( ) )
2008-04-11 10:11:29 +02:00
{
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
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-04-11 10:11:29 +02:00
input_file . getline ( buffer , BUFFER_LENGTH ) ;
2008-04-30 11:36:55 +02:00
2008-04-15 12:19:15 +02:00
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
2008-04-11 10:11:29 +02:00
{
/* Extract fields */
cpp_buffer = buffer ;
2008-04-30 11:36:55 +02:00
if ( cpp_buffer . size ( ) = = 0 ) // Ignorer une ligne vide
continue ;
2008-05-07 10:59:06 +02:00
2008-04-11 10:11:29 +02:00
infos = extractReferencePointInfoFromBuffer ( cpp_buffer ) ;
x = string2float ( infos [ 0 ] ) ;
y = string2float ( infos [ 1 ] ) ;
2008-04-30 11:36:55 +02:00
# ifdef FRED_CSV_FORMAT
z = DEFAULT_Z ;
2008-05-07 10:59:06 +02:00
# else // FRED_CSV_FORMAT
2008-04-30 11:36:55 +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-04-11 10:11:29 +02:00
/* Set point coordinates */
tmp_point . setX ( x ) ;
tmp_point . setY ( y ) ;
2008-04-30 11:36:55 +02:00
tmp_point . setZ ( z ) ;
2008-04-11 10:11:29 +02:00
/* Use C++ string format */
2008-05-07 10:59:06 +02:00
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,
2008-04-11 10:11:29 +02:00
{
rp . setCoordinates ( tmp_point ) ;
2008-05-07 10:59:06 +02:00
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-04-30 11:36:55 +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-04-30 11:36:55 +02:00
cout < < tmp_point < < " : ajouté. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-04-30 11:36:55 +02:00
}
2008-05-07 10:59:06 +02:00
else // Le point existe déjà :
2008-04-30 11:36:55 +02:00
{
2008-05-07 10:59:06 +02:00
# ifdef DEBUG_2
2008-04-30 11:36:55 +02:00
cout < < tmp_point < < " : existe déjà. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
pt_idx = pointIndex ( dest_point_list , tmp_point ) ; // On recherche le point auquel on veut ajouter les informations.
2008-04-11 10:11:29 +02:00
}
2008-04-30 11:36:55 +02:00
# ifdef FRED_CSV_FORMAT
vector < int > measures_vector = extractValues ( infos [ 4 ] ) ;
2008-05-05 13:59:55 +02:00
for ( unsigned int i = 0 ; i < measures_vector . size ( ) ; i + + )
dest_point_list [ pt_idx ] . addMeasurement ( infos [ 3 ] , measures_vector [ i ] ) ;
2008-04-30 11:36:55 +02:00
measures_vector . clear ( ) ;
2008-05-07 10:59:06 +02:00
# else // FRED_CSV_FORMAT
2008-05-05 13:59:55 +02:00
for ( unsigned int i = 4 ; i < infos . size ( ) ; i + + )
2008-04-30 11:36:55 +02:00
{
# ifdef DEBUG_2
cout < < " Lecture de la valeur : " < < infos [ i ] < < " ... " ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG_2
2008-04-30 11:36:55 +02:00
if ( i + 1 < infos . size ( ) )
{
2008-05-05 13:59:55 +02:00
dest_point_list [ pt_idx ] . addMeasurement ( infos [ i ] , string2int ( infos [ i + 1 ] ) ) ;
2008-04-30 11:36:55 +02:00
# ifdef DEBUG_2
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-04-30 11:36:55 +02:00
i + + ;
}
}
2008-05-07 10:59:06 +02:00
# endif // FRED_CSV_FORMAT
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
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-04-11 10:11:29 +02:00
input_file . close ( ) ;
2008-04-30 11:36:55 +02:00
infos . clear ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::makePointListFromFile(&vector<ReferencePoint>, &string, bool) " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::makeApListFromFile() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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-04-11 10:11:29 +02:00
input_file . open ( filename . c_str ( ) ) ;
2008-04-15 12:19:15 +02:00
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
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-04-15 12:19:15 +02:00
while ( ! input_file . eof ( ) )
2008-04-11 10:11:29 +02:00
{
input_file . getline ( buffer , BUFFER_LENGTH ) ;
2008-04-30 11:36:55 +02:00
2008-04-15 12:19:15 +02:00
if ( ( input_file . rdstate ( ) & ifstream : : eofbit ) = = 0 )
2008-04-11 10:11:29 +02:00
{
2008-04-30 11:36:55 +02:00
/* Traitement basique des commentaires */
if ( buffer [ 0 ] = = ' \0 ' // Ligne vide
| | buffer [ 0 ] = = ' # ' ) // ou ligne commençant par #
continue ; // ignorer cette ligne.
2008-04-11 10:11:29 +02:00
ap_infos = explode ( buffer , ' ; ' ) ;
2008-04-30 11:36:55 +02:00
# ifdef DEBUG
cout < < " AP : " < < buffer ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-11 10:11:29 +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
cout < < " ajouté. " < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
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
cout < < endl ;
2008-05-07 10:59:06 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
2008-04-11 10:11:29 +02:00
input_file . close ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::makeApListFromFile() " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::makeTopologyFromFile() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-29 10:48:05 +02:00
ifstream input_file ;
char buffer [ BUFFER_LENGTH ] ;
vector < string > infos ;
input_file . open ( filename . c_str ( ) ) ;
if ( input_file . fail ( ) )
{
cerr < < " Error opening input file « " < < filename < < " » ! " < < endl ;
return ;
}
# ifdef DEBUG
cout < < " Lecture du fichier « " < < filename < < " »... " < < endl ;
# endif // DEBUG
while ( ! input_file . eof ( ) )
{
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.
infos = explode ( buffer , ' ; ' ) ;
# ifdef DEBUG
cout < < " Pièce : " < < buffer ;
# 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
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 [ 2 ] ) , string2float ( infos [ 3 ] ) , string2float ( infos [ 4 ] ) , string2float ( infos [ 5 ] ) , string2float ( infos [ 6 ] ) ) ;
2008-05-29 10:48:05 +02:00
# ifdef 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
cout < < " ajoutée. " < < endl ;
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-05-29 10:48:05 +02:00
infos . clear ( ) ;
}
}
# ifdef DEBUG
cout < < " --> Liste des pièces ( " < < area_list . size ( ) < < " ) : " < < 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
for ( map < string , Area > : : iterator it = area_list . begin ( ) ; it ! = area_list . end ( ) ; it + + )
2008-05-29 10:48:05 +02:00
cout < < it - > first < < " : " < < it - > second < < endl ;
cout < < endl ;
# endif // DEBUG
input_file . close ( ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::makeTopologyFromFile() " < < endl ; fflush ( stdout ) ;
# 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
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
cout < < " //--> Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
2008-06-20 12:37:25 +02:00
# endif // DEBUG_T
2008-05-29 10:48:05 +02:00
ifstream input_file ;
char buffer [ BUFFER_LENGTH ] ;
vector < string > infos ;
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
set < Point > point_list ;
// Point p_cur, p_tmp ;
2008-05-29 10:48:05 +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
cout < < " //<-- Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-29 10:48:05 +02:00
return ;
}
# ifdef DEBUG
cout < < " Lecture du fichier « " < < filename < < " »... " < < endl ;
# endif // DEBUG
while ( ! input_file . eof ( ) )
{
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.
infos = explode ( buffer , ' ; ' ) ;
# ifdef 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
cout < < " Point de passage : " < < buffer ; 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
/* 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 < < " dupliqué ! " < < endl ;
else
2008-05-29 10:48:05 +02:00
# ifdef 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
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
infos . clear ( ) ;
2008-05-29 10:48:05 +02:00
}
}
input_file . close ( ) ; // Lecture du fichier terminée
/* Construction de la matrice */
unsigned int nb_pts = point_list . size ( ) ; // Nombre de 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
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 ;
}
2008-05-29 10:48:05 +02:00
# ifdef 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
cout < < " --> Liste des points de passage ( " < < nb_pts < < " ) : " < < 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
/* Calcul des distances */
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
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
cout < < * it < < " : " ;
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
waypoint_list [ cur_idx ] = * it ; // Ajout du point dans waypoint_list // FIXME : utiliser plutôt push_back() ?
waypoint_matrix [ cur_idx ] [ cur_idx ] = 0 ; // La distance du point à lui-même est nulle
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
for ( unsigned int k = 0 ; k < cur_idx ; k + + ) // Pour chacun des point précédent
{
2008-05-29 10:48:05 +02:00
# ifdef 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
cout < < " / " < < waypoint_list [ k ] ;
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
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
# ifdef DEBUG
cout < < " / " < < endl ;
# endif // DEBUG
}
# ifdef DEBUG
/* Affichage de la matrice */
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
cout < < " --> Matrice des distances entre points de passage : \n \t \t | " ;
2008-05-29 10:48:05 +02:00
for ( unsigned int k = 0 ; k < nb_pts ; 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
cout < < ' ' < < waypoint_list [ k ] < < " \t | " ;
2008-05-29 10:48:05 +02:00
cout < < endl ;
for ( unsigned int k = 0 ; k < nb_pts ; 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
cout < < waypoint_list [ k ] < < " \t | " ;
2008-05-29 10:48:05 +02:00
for ( unsigned int l = 0 ; l < nb_pts ; l + + )
cout < < ' \t ' < < waypoint_matrix [ k ] [ l ] < < " \t | " ;
cout < < endl ;
}
cout < < endl ;
# endif // DEBUG
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
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
cout < < " //<-- Server::makeWaypointListFromFile() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
}
/* 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
cout < < " //--> Server::makeReferencePointDistances() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
unsigned int nb_pts = reference_point_list . size ( ) ; // Nombre de points à traiter.
/* 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 ;
}
# ifdef DEBUG
cout < < " --> Liste des points de référence ( " < < nb_pts < < " ) : " < < endl ; fflush ( stdout ) ;
# endif // DEBUG
/* Calcul des distances */
for ( unsigned int cur_idx = 0 ; cur_idx < nb_pts ; cur_idx + + )
{
# ifdef DEBUG
cout < < ( Point ) reference_point_list [ cur_idx ] ;
# ifdef DEBUG_2
cout < < " : " ;
# endif // DEBUG_2
# endif // DEBUG
reference_point_matrix [ cur_idx ] [ cur_idx ] = 0 ; // La distance du point à lui-même est nulle
for ( unsigned int k = 0 ; k < cur_idx ; k + + ) // Pour chacun des point précédent
{
# ifdef DEBUG_2
cout < < " / " < < ( Point ) reference_point_list [ k ] ;
# endif // DEBUG_2
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.
}
# ifdef DEBUG
# ifdef DEBUG_2
cout < < " / " ;
# endif // DEBUG_2
cout < < endl ;
# endif // DEBUG
}
# ifdef DEBUG_2
/* 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 ;
# endif // DEBUG_2
# ifdef DEBUG_T
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-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
cout < < " //--> Server::printReferencePointList() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-05 13:59:55 +02:00
printPointList ( reference_point_list ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::printReferencePointList() " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::printPointList() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-05 13:59:55 +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
cout < < " //<-- Server::printPointList() " < < endl ; fflush ( stdout ) ;
# 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 : : printAccessPointList ( )
{
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //--> Server::printAccessPointList() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-05-05 13:59:55 +02:00
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
cout < < access_point_list [ i ] < < endl ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::printAccessPointList() " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::computeFriisFromRefList() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-11 10:11:29 +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-05-05 13:59:55 +02:00
for ( unsigned int i = 0 ; i < access_point_list . size ( ) ; i + + )
2008-04-11 10:11:29 +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 */
2008-05-05 13:59:55 +02:00
for ( unsigned int j = 0 ; j < reference_point_list . size ( ) ; j + + )
2008-04-11 10:11:29 +02:00
{
pt_coords = reference_point_list [ j ] . getCoordinates ( ) ;
2008-04-15 12:19:15 +02:00
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-04-11 10:11:29 +02:00
}
2008-05-05 13:59:55 +02:00
2008-04-11 10:11:29 +02:00
/* Now, compute avg value */
friis_sum = 0 ;
2008-05-05 13:59:55 +02:00
for ( unsigned int j = 0 ; j < friis_idx_list . size ( ) ; j + + )
2008-04-11 10:11:29 +02:00
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-04-11 10:11:29 +02:00
cout < < access_point_list [ i ] . getApAddr ( ) < < " -> " < < ( friis_sum / friis_idx_list . size ( ) ) < < endl ;
2008-05-05 13:59:55 +02:00
2008-04-11 10:11:29 +02:00
friis_idx_list . clear ( ) ;
}
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::computeFriisFromRefList() " < < endl ; fflush ( stdout ) ;
# 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
cout < < " //--> Server::computeFriisFromRefList(&Point, &vector<Measurement>) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-17 11:08:26 +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 ;
/* 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 < access_point_list . size ( ) ; i + + )
{
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 ;
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 ) ) ) ) ;
}
}
}
}
for ( unsigned int k = 0 ; k < friis_idx_list . size ( ) ; k + + )
cout < < " friis_idx_list " < < k < < " : " < < friis_idx_list [ k ] < < endl ; //
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::computeFriisFromRefList(&Point, &vector<Measurement>) " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-17 11:08:26 +02:00
return friis_idx_list ;
}
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
cout < < " //--> Server::createClient() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-12 13:27:34 +02:00
client_list . push_back ( ClientInfo ( ) ) ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::createClient() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-12 13:27:34 +02:00
return client_list . back ( ) ;
}
/* 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-06-12 13:27:34 +02:00
cout < < " //--> Server::monitorClient() " < < endl ; fflush ( stdout ) ;
2008-06-11 17:04:50 +02:00
# endif // DEBUG_T
2008-06-20 12:37:25 +02:00
Point pointFastViterbi ;
vector < float > friisFromList ;
2008-04-30 11:36:55 +02:00
vector < Point >
2008-06-12 13:27:34 +02:00
& E_current = client_list [ client_id ] . getRef_viterbi_Ecurrent ( ) ,
& E_previous = client_list [ client_id ] . getRef_viterbi_Eprevious ( ) ;
2008-04-30 11:36:55 +02:00
2008-06-12 13:27:34 +02:00
if ( VITERBI_N < 2 )
2008-04-11 10:11:29 +02:00
{
2008-06-12 13:27:34 +02:00
cerr < < " monitorClient() : N ne peut être inférieur à 2 ! " < < endl ;
2008-06-20 12:37:25 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::monitorClient() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-04-30 11:36:55 +02:00
return ;
2008-04-11 10:11:29 +02:00
}
2008-06-12 13:27:34 +02:00
# ifdef TEST
vector < ReferencePoint > peregrination_point_list ;
makePointListFromFile ( peregrination_point_list , DEFAULT_TRACKING_FILE , false ) ;
# endif // TEST
2008-06-11 17:04:50 +02:00
2008-05-07 10:59:06 +02:00
# ifdef DEBUG
2008-05-26 15:15:33 +02:00
cout < < reference_point_list . size ( ) < < " points de référence " ;
# ifdef TEST
cout < < " , " < < peregrination_point_list . size ( ) < < " points de pérégrination. " < < endl ;
# else // TEST
cout < < ' . ' < < endl ;
# endif // TEST
# endif // DEBUG
# ifdef 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
cout < < " ***** Liste des points de référence : ***** " < < endl ;
2008-05-07 10:59:06 +02:00
printReferencePointList ( ) ;
2008-05-26 15:15:33 +02:00
# ifdef TEST
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
cout < < " ***** Liste des points de pérégrination : ***** " < < endl ;
2008-05-07 10:59:06 +02:00
printPointList ( peregrination_point_list ) ;
2008-05-26 15:15:33 +02:00
# endif // TEST
2008-05-07 10:59:06 +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
unsigned int pt = 0 ;
2008-05-05 13:59:55 +02:00
while ( pt < peregrination_point_list . size ( ) )
2008-05-07 10:59:06 +02:00
# else // TEST
2008-04-30 11:36:55 +02:00
while ( true )
2008-05-07 10:59:06 +02:00
# endif // TEST
2008-04-30 11:36:55 +02:00
{
vector < Measurement > vm ;
# ifdef TEST
/* Get point measurements */
2008-05-05 13:59:55 +02:00
//vm.clear();
vm = peregrination_point_list [ pt ] . getMeasurementList ( ) ;
2008-06-12 13:27:34 +02:00
# else // TEST
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-04-30 11:36:55 +02:00
E_previous = E_current ;
2008-06-12 13:27:34 +02:00
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
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
switch ( algo )
2008-06-17 11:08:26 +02:00
{
2008-06-18 13:51:09 +02:00
case ALGO_VLI : /* Application de l'algorithme Viterbi */
fastViterbiLike ( client_id , NULL ) ;
break ;
case ALGO_BASIC_FRBHM : /* Application de l'algorithme FRBHM basique */
cout < < " -------FRBHM--------- " < < endl ;
computeFriisFromRefList ( ) ;
pointFastViterbi = fastViterbiLike ( client_id , NULL ) ;
friisFromList = computeFriisFromRefList ( pointFastViterbi , vm ) ;
fbcm_friis ( vm , friisFromList ) ;
break ;
default :
cerr < < " Erreur ! Algorithme inconnu. " < < endl ;
}
2008-06-12 13:27:34 +02:00
# ifdef TEST
pt + + ;
# endif // TEST
}
# ifdef DEBUG_T
cout < < " //<-- Server::monitorClient() " < < endl ; fflush ( stdout ) ;
# 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 .
*/
Point Server : : fastViterbiLike ( const unsigned int & client_id , float * * distance_matrix )
{
# ifdef DEBUG_T
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 ( ) ,
& E_previous = client_list [ client_id ] . getRef_viterbi_Eprevious ( ) ;
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
if ( i > 1 ) // Si on n'est plus à la première itération
{
/* 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 ] + E_previous [ 0 ] . distance ( E_current [ k ] ) ;
for ( float_index l = 1 ; l < K ; l + + )
{
float f = V [ n + 1 ] [ l ] + E_previous [ l ] . distance ( E_current [ k ] ) ;
if ( f < V [ n ] [ k ] )
V [ n ] [ k ] = f ;
2008-04-30 11:36:55 +02:00
}
2008-06-12 13:27:34 +02:00
}
2008-04-30 11:36:55 +02:00
2008-06-12 13:27:34 +02:00
/* 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 ] = E_previous [ 0 ] . distance ( E_current [ k ] ) ;
for ( float_index l = 1 ; l < K ; l + + )
{
float f = E_previous [ l ] . distance ( E_current [ k ] ) ;
if ( f < V [ N - 2 ] [ k ] )
V [ N - 2 ] [ k ] = f ;
2008-04-30 11:36:55 +02:00
}
2008-06-12 13:27:34 +02:00
}
2008-04-30 11:36:55 +02:00
2008-06-12 13:27:34 +02:00
/* 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-06-12 13:27:34 +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-06-12 13:27:34 +02:00
for ( float_index k = 1 ; k < K ; k + + )
{
if ( V [ 0 ] [ k ] < V0_min )
2008-04-30 11:36:55 +02:00
{
2008-06-12 13:27:34 +02:00
V0_min_k = k ;
2008-05-26 15:15:33 +02:00
# ifdef DEBUG
2008-06-12 13:27:34 +02:00
V0_min = V [ 0 ] [ k ] ;
2008-05-26 15:15:33 +02:00
# endif // DEBUG
2008-04-30 11:36:55 +02:00
}
2008-05-26 15:15:33 +02:00
# ifdef DEBUG
2008-06-12 13:27:34 +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-04-30 11:36:55 +02:00
}
2008-06-12 13:27:34 +02:00
# ifdef DEBUG
cout < < " V0_min = " < < V0_min < < " ; V0_min_k= " < < V0_min_k < < endl ;
# endif // DEBUG
2008-04-30 11:36:55 +02:00
}
2008-06-12 13:27:34 +02:00
}
2008-04-11 10:11:29 +02:00
2008-05-05 13:59:55 +02:00
# ifdef DEBUG
2008-06-12 13:27:34 +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-06-12 13:27:34 +02:00
if ( i < N - 1 )
i + + ;
2008-06-11 17:04:50 +02:00
# ifdef DEBUG_T
cout < < " //<-- Server::fastViterbiLike() " < < endl ; fflush ( stdout ) ;
# endif // DEBUG_T
2008-06-12 13:27:34 +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 */
void Server : : radar_exp ( )
{
ofstream logfile ;
vector < Point > solutions ;
Point solution , solution_kw , ref_coords ;
unsigned int i ;
vector < Measurement > vm ;
2008-04-30 11:36:55 +02:00
// computeFriisFromRefList();
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Open a log file */
2008-04-15 12:19:15 +02:00
logfile . open ( DEFAULT_LOGFILE ) ;
if ( logfile . fail ( ) )
{
cerr < < " Error opening output file « " < < logfile < < " » ! " < < endl ;
return ;
}
2008-04-11 10:11:29 +02:00
/* Column names */
logfile < < " Coordinates \t 2-kss \t (Error) \t 3-kss \t (Error) \t 4-kss \t (Error) \t 5-kss \t (Error) \t nss \t (Error) \t Interlink \t (Error) \t FBCM \t (Error) " < < endl ;
2008-04-15 12:19:15 +02:00
cout < < reference_point_list . size ( ) < < " reference points. " < < endl ;
for ( i = 0 ; i < reference_point_list . size ( ) ; i + + )
2008-04-11 10:11:29 +02:00
{
/* Get point measurements */
vm . clear ( ) ;
vm = reference_point_list [ i ] . getMeasurementList ( ) ;
ref_coords = reference_point_list [ i ] . getCoordinates ( ) ;
/* Print point coordinates */
logfile < < ref_coords < < " \t " ;
/* From 2 to 5 K-weighted-SS */
2008-04-30 11:36:55 +02:00
solution = getkWeightedInSs ( vm , 2 , & ref_coords ) ;
2008-04-11 10:11:29 +02:00
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-04-30 11:36:55 +02:00
solution = getkWeightedInSs ( vm , 3 , & ref_coords ) ;
2008-04-11 10:11:29 +02:00
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-04-30 11:36:55 +02:00
solution = getkWeightedInSs ( vm , 4 , & ref_coords ) ;
2008-04-11 10:11:29 +02:00
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-04-30 11:36:55 +02:00
solution = getkWeightedInSs ( vm , 5 , & ref_coords ) ;
2008-04-11 10:11:29 +02:00
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
2008-04-15 12:19:15 +02:00
2008-04-11 10:11:29 +02:00
/* Nearest in SS */
2008-04-30 11:36:55 +02:00
solutions = getkClosestInSs ( vm , 1 , & ref_coords ) ;
2008-04-11 10:11:29 +02:00
logfile < < solutions [ 0 ] < < " \t " < < solutions [ 0 ] . distance ( ref_coords ) < < " \t " ;
/* Interlink Networks */
solution = interlink ( vm , 0 ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < " \t " ;
/* FBCM */
solution = fbcm ( vm , 0 ) ;
logfile < < solution < < " \t " < < solution . distance ( ref_coords ) < < endl ;
solutions . clear ( ) ;
}
logfile . close ( ) ;
}