Simulateur de position : geolocalisation

Version imprimable

03/05/2007, 13h16
minette

Simulateur de position : geolocalisation

Bonjour,
j'essai de simuler en java la position d'une persone X se trouvant dans une Salle Y. Pour cela je cree une collection qui va se charger de cela.
Cependant c'est assez statique et je souhaite passer au cap suivant :
cad changer aleatoirement et dynamiquement les noms des personnes ou de la salle ou elle se trouvent. (je rentre ou je sor d'une salle a ma convenance)
Pour cela je pensait faire un thread qui allai se mettre a l'ecoute de ce changement mais comment ? ( je ne maitrise pas bien les threads)

Si vous avez des idees ou des propositions ce serai interessant et ça permettrai un echange mutuel.
Merci...

Voici ma classe :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
public class Affectations {
   private SortedMap<String,SortedSet<String>> salles = new TreeMap<String,SortedSet<String>>(5);
   private SortedMap<String,String> personnes = new TreeMap<String,String>();
 
   Affectations() {}
 
   public SortedSet<String> getAllOnes() {
      synchronized( this ) {
        return new TreeSet<String>( this.personnes.keySet() );
      }
   }
 
   public SortedSet<String> getAllRooms() {
      synchronized( this ) {
        return new TreeSet<String>( this.salles.keySet() );
      }
   }
 
   public boolean containsOne( String personne ) {
      synchronized( this ) {
        return this.personnes.containsKey( personne );
      }
   }
 
   public String whereIs( String personne ) {
     synchzonied( this ) {
       return this.personnes.get( personne );
     }
   }
 
   public SortedSet<String> getFrom( String salle ) {
     synchronized( this ) {
       return new TreeSet<String>( this.salles.get(salle) );
     }
   }
 
   public void add( String salle, String personne ) {
      synchronized( this ) {
        SortedSet<String> personnes = this.salles.get( salle );
        if ( personnes == null ) {
          personnes = this.create( salle );
        }
        if ( personne != null ) { 
            if ( this.containsOne( personne ) ) this.remove( personne );
            personnes.add( personne );
            this.personnes.add( personne, salle );
        }
      }
   }
 
   public void remove( String personne ) {
     synchronized( this ) {
         String salle = this.personnes.get( personne );
         if ( salle != null ) {
           this.salles.get( salle ).remove( personne );
           this.personnes.remove( personne );
         }
     }
   }
 
   private SortedSet<String> create( String salle ) {
      synchronized( this ) {
        if ( this.salles.containsKey( salle ) ) return this.salles.get( salle );
        SortedSet<String> resultat = new TreeSet<String>();
        this.salles.add( resultat );
        return resultat;
      }
   }
 
   public void print() { ... }
}
 
 
public class ChangementAleatoire extends Thread {
 
     public static final int EVENT_NOTHING     = 3;
     public static final int EVENT_NEW_ROOM  = 0;
     public static final int EVENT_NEW_ONE    = 1;
     public static final int EVENT_CHANGE      = 2;
 
     private double[] probabilité = double[EVENT_NOTHING];
     private int time;
     private Affectations affectations;
     private boolean isRun = true;
 
     ChangementAleatoire( double changeRoomHappend, double changeOneHappend, double changeHappend, int timeToWait, Affectations affectations ) {
        probabilité[ EVENT_NEW_ROOM ] =  changeRoomHappend;
        probabilité[ EVENT_NEW_ONE ] = probabilité[ EVENT_NEW_ROOM ] + changeOneHappend;
        probabilité[ EVENT_CHANGE ] = probabilité[ EVENT_NEW_ONE ] + changeHappend;
        time = timeToWait;
        this.affectations = affectations;
     }
 
     public String buildRandomName() { ... }
     public String getRandomPersonne() { .... }
     public String getRandomSalle() {...}
 
     public void run() {
        try {
           while ( isRun ) {
              double p = Math.random();
              int i = 0;
              while ( probabilité[i]>p || (++i)<probabilité.length );
              switch ( i ) {
                  case EVENT_NEW_ROOM:
                      this.affectations.add( buildRandomName(), getRandomPersonne() );
                      break;
                  case EVENT_NEW_ONE:
                      this.affectations.add( getRandomSalle(), buildRandomName() );
                      break;
                  case EVENT_CHANGE:
                      this.affectations.add( getRandomSalle(), getRandomPersonne() );
                      break;                  
                  case EVENT_NOTHING:
                      // Do nothing
                      break;
                  default:
                     // An error occurs 
                     System.err.println("Erreur fatale : probabilité non envisagée");
                     System.exit( 10 );
              }
              this.affectations.print();
           }
 
         } catch ( ... ) {
         }
     }
 
     public void stopRun() { isRun = false; }
}
 
 
public class Main {
  public static final void main(String[] args) {
    new ChangementAleatoire( 0.1D, 0.1D, 0.6D, 500, new Affectations()).start();
  }

Citation:

Envoyé par Nemek

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
public class Affectations {
   private SortedMap<String,SortedSet<String>> salles = new TreeMap<String,SortedSet<String>>(5);
   private SortedMap<String,String> personnes = new TreeMap<String,String>();
 
   Affectations() {}
 
   public SortedSet<String> getAllOnes() {
      synchronized( this ) {
        return new TreeSet<String>( this.personnes.keySet() );
      }
   }
 
   public SortedSet<String> getAllRooms() {
      synchronized( this ) {
        return new TreeSet<String>( this.salles.keySet() );
      }
   }
 
   public boolean containsOne( String personne ) {
      synchronized( this ) {
        return this.personnes.containsKey( personne );
      }
   }
 
   public String whereIs( String personne ) {
     synchzonied( this ) {
       return this.personnes.get( personne );
     }
   }
 
   public SortedSet<String> getFrom( String salle ) {
     synchronized( this ) {
       return new TreeSet<String>( this.salles.get(salle) );
     }
   }
 
   public void add( String salle, String personne ) {
      synchronized( this ) {
        SortedSet<String> personnes = this.salles.get( salle );
        if ( personnes == null ) {
          personnes = this.create( salle );
        }
        if ( personne != null ) { 
            if ( this.containsOne( personne ) ) this.remove( personne );
            personnes.add( personne );
            this.personnes.add( personne, salle );
        }
      }
   }
 
   public void remove( String personne ) {
     synchronized( this ) {
         String salle = this.personnes.get( personne );
         if ( salle != null ) {
           this.salles.get( salle ).remove( personne );
           this.personnes.remove( personne );
         }
     }
   }
 
   private SortedSet<String> create( String salle ) {
      synchronized( this ) {
        if ( this.salles.containsKey( salle ) ) return this.salles.get( salle );
        SortedSet<String> resultat = new TreeSet<String>();
        this.salles.add( resultat );
        return resultat;
      }
   }
 
   public void print() { ... }
}
 
 
public class ChangementAleatoire extends Thread {
 
     public static final int EVENT_NOTHING     = 3;
     public static final int EVENT_NEW_ROOM  = 0;
     public static final int EVENT_NEW_ONE    = 1;
     public static final int EVENT_CHANGE      = 2;
 
     private double[] probabilité = double[EVENT_NOTHING];
     private int time;
     private Affectations affectations;
     private boolean isRun = true;
 
     ChangementAleatoire( double changeRoomHappend, double changeOneHappend, double changeHappend, int timeToWait, Affectations affectations ) {
        probabilité[ EVENT_NEW_ROOM ] =  changeRoomHappend;
        probabilité[ EVENT_NEW_ONE ] = probabilité[ EVENT_NEW_ROOM ] + changeOneHappend;
        probabilité[ EVENT_CHANGE ] = probabilité[ EVENT_NEW_ONE ] + changeHappend;
        time = timeToWait;
        this.affectations = affectations;
     }
 
     public String buildRandomName() { ... }
     public String getRandomPersonne() { .... }
     public String getRandomSalle() {...}
 
     public void run() {
        try {
           while ( isRun ) {
              double p = Math.random();
              int i = 0;
              while ( probabilité[i]>p || (++i)<probabilité.length );
              switch ( i ) {
                  case EVENT_NEW_ROOM:
                      this.affectations.add( buildRandomName(), getRandomPersonne() );
                      break;
                  case EVENT_NEW_ONE:
                      this.affectations.add( getRandomSalle(), buildRandomName() );
                      break;
                  case EVENT_CHANGE:
                      this.affectations.add( getRandomSalle(), getRandomPersonne() );
                      break;                  
                  case EVENT_NOTHING:
                      // Do nothing
                      break;
                  default:
                     // An error occurs 
                     System.err.println("Erreur fatale : probabilité non envisagée");
                     System.exit( 10 );
              }
              this.affectations.print();
           }
 
         } catch ( ... ) {
         }
     }
 
     public void stopRun() { isRun = false; }
}
 
 
public class Main {
  public static final void main(String[] args) {
    new ChangementAleatoire( 0.1D, 0.1D, 0.6D, 500, new Affectations()).start();
  }

Pourrai je avoir quelques explications STP ??? entre ton code et le mien je ne me retrouve pas :aie:

Euh désolé, j'étais un peu pressé alors j'ai pas trop mis d'explication ^_^

Donc je reprend :

La classe Affectaction gère une sorte de liste de clients. Si j'étais toi j'aurais déjà créer une classe Personne (avec un nom), Client (qui hérite de Personne et qui se situe dans une Salle) et Salle (avec un nom).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
public class Personne {
  private String _nom;
 
  public Personne( String nom ) {
    // Le nom est obligatoire
    assert( nom!=null );
    _nom = nom;
  }
 
  public String getNom() {
    return _nom;
  }
 
  public String toString() {
    return "Personne[" + getNom() + "]";
  } 
}
 
public class Client extends Personne {
 
   private Salle _localisation;
 
   public Client( String nom, Salle localisation ) {
     super( nom );
     // La salle n'est pas obligatoire
     setSalle( localisation );
   }
 
   public Client( String nom ) {
     this( nom, null );
   }
 
   public Salle getSalle() {
      return _localisation;
   }
 
   protected void setSalle( Salle localisation ) {
      _localisation = localisation;
   }
}
 
 
public class Salle {
  private String _nom;
  private SortedMap<String,Client> _clients = new SortedMap<String,Client>();
 
  public Salle( String nom ) {
    // Le nom est obligatoire
    assert( nom!=null );
    _nom = nom;
  }
 
  public String getNom() {
    return _nom;
  }
 
  public boolean isEmpty() {
    return _clients.isEmpty();
  }
 
  protected void addClient( Client client ) {
     _clients.add( client.getNom(), client );
  }
 
  protected void removeClient( Object clientID ) {
     if ( clientID instanceof Client ) _clients.remove( ((Client)clientID).getNom );
     else _clients.remove( clientID.toString() );
  }
 
  proctected Client getClientByName( String nom ) {
     return _clients.get( nom );
  }
}

Ensuite il faut une classe qui gère

La liste des salles
La liste des clients
Les affectations

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public interface GeoLocalisation {
   // Retourne l'ensemble des clients
   public SortedSet<Client> getClients();
   // Retourne l'ensemble des clients
   public SortedSet<Salle> get Salles();
 
   // Retourne le client dont le nom est indiqué en paramètre
   public Client getClientByName( String nom );
   // Retourne la salle dont le nom est indiqué en paramètre
   public Salle getSalleByName( String nom );
   // Retourne l'ensemble des clients situés dans la salle donnée
   public SortedSet<Client> getClientsInner( Salle salle );
   // Retourne la salle où se situe un client donné
   public Salle getWhereIs( Client client ) ;
 
   // Ajoute un nouveau client nommé "nom" et qui se trouverait éventuellement dans la salle donnée
   public Client addNewClient( String nom, Salle salle );
   // Idem avec un client créé prélablement
   public void addClient( Client client, Salle salle );
   // Retire le client de la liste et des salles
   public void removeClient( Client client );
 
   // Idem
   public Salle addNewSalle( String nom );
   public void addSalle( Salle salle );
   public void removeSalle( Salle salle );
 
   // Déplace le client donné vers la salle donnée
   public Salle moveClient( Client client, Salle newSalle );
}
 
 
class GeoLocalisationImpl implements GeoLocalisation {
 
}

En t'inspirant de la classe Affectations tu devrais pouvoir écrire l'implémentation de GeoLocalisation. Concernant le Thread il faudra remplacer Affectations par GeoLocalisation et adapté les appels de méthodes. Le principe restant le même

Si tu as d'autres questions je reste pas loin ;-)

04/05/2007, 13h02
minette

merci, il y a encore quelque beug :

Code:

private SortedMap<String,Client> _clients = new SortedMap<String,Client>();

probleme a cette ligne ( can not instanciate this type)

Ensuite dois je modifier ma classe Entity Meeting ou la laisser intacte.
Au final ma collection contenue dans entitMeeting me sert a charger cette collection dans la memoire courante (moteur de regle Jess) afin de creer des regles sur les personnes ( exemples : 2 personne dans une salle == EN Meeting). Pour etre concret c'est cela qui m'amene a faire changer automatiquement de salle aux Clients et le faire prendre en compte grace a mon moteur :
04/05/2007, 13h23
Logan Mauzaize
Euh n'ayant aucune connaissance de Jess, je dois avouer que mon aide risque d'être limité.

Ma proposition était effectivement de changer la conception pour rajouter :
- Une classe Salle. Le problème est que les String sont des instances différentes.
- La navigation de Client vers la Salle. On peut comparer les Salles avec l'opérateur "=="
- La navigation de Salle vers les Clients. On peut ainsi lister les Clients d'une salle.
Autrement il faut remplacer "new SortedMap" par "new TreeMap".
La classe EntityMeeting a deux rôles : stocker les données et faire le jeu d'essai. Avec GeoLocalisation tu n'en as plus besoin. GeoLocalisation a pour but de simplifier la gestion des données. Ainsi changer quelqu'un de salle est aisé et on peut rapidement retrouver l'information.

Du coup coder un Thread qui modifie les données aléatoirement devient beaucoup plus simple. Toutefois dans le cadre de l'utilisation avec JESS, je ne sais pas comment faire fonctionner le tout. Il faudrait que j'en sache plus sur la finalité du "projet" et sur le fonctionnement de JESS.

Pour commencer je ne sais même pas ce qu'est censé faire JESS...
04/05/2007, 14h26
minette

oui je comprend, moi aussi je decouvre
04/05/2007, 14h58
Logan Mauzaize

Ok je vais regarder ça ... Et voir comment cela s'intègre dans des classes existentes...

Concernant les Maps, il existe une interface (SortedMap) et une classe concrète (TreeMap). En général on utilise les interface pour les attributs, les paramètres et valeurs de retour. Ca permet de gagner en flexibilité.

Les classes concrètes sont utilisés uniquement au moment de l'instanciation.
04/05/2007, 15h06
minette
Oui j'ai vu ça pour le SortedMap, sauf que lors de cette instanciation il me dit qu'il n'y arrive pas.

Code:

private SortedMap<String,String> personnes = new SortedMap<String,String>();

que j'ai remplacé par

Code:

private SortedMap<String,Client> _clients = new TreeMap<String,Client>();

Le dernier pbm se situe a ce niveau maintenant. Eclipse me demande de caster mais qd je le fait l'erreur persiste.
Code:

1 2 3 protected void addClient(Client client) { _clients.add(client.getName(), client); }
Pour Jess il y a une interface avec Java grace a une librairie.
Tu verra dans le document que je t'ai laissé. C'est tres puissant mais
je continu de patauger, c'est ensuite que je construirai :yaisse2: :king:

Merci

Code:

1
2
3
4
protected void addClient(Client client) {
     _clients.add(client.getNom(), client);
  }

oui merci,
en fait j'ai renommé le getNom en getName.
J'ai une preference pour les mots en anglais :mouarf: quoique mon niveau en anglais soit pas si top 8O .

Eclipse me propose de caster mais quand je cast rien a faire l'erreur persiste.Epuis c'est le Add qu'il souligne*.

En fait voila le soucis, quand je fais

Code:

_clients.

le menu contextuel intellisense ne met pas add dans la liste d'option possible.

Code:

_clients.add(client.getName(), client);

voici le message d'erreur
Code:

1 2 3 Multiple markers at this line - The method add(String, Client) is undefined for the type SortedMap<String,Client> - The method add(String, Client) is undefined for the type SortedMap<String,Client>

04/05/2007, 16h22
Logan Mauzaize

Pardonne moi c'est entièrement de ma faute !

ce n'est pas "add" mais "put" pour les Maps ;-)
07/05/2007, 10h50
minette

Bonjour, la classe que je ne comprend en ce moment
c'est la classe Affectation qui doit etre remplacée par la class Geolocalisation.

Epuis comment alimenter tous ces map??

Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
// Ajoute un nouveau client nommé "nom" et qui se trouverait éventuellement dans la salle donnée
   public Client addNewClient( String name, Room room) {
       Client client = new Client( name);
       this.addClient( client, room);
       return client;
   }
   // Idem avec un client créé prélablement
   public void addClient( Client client, Room room) {
     synchronized( this ) {
        client.setRoom( room );
        this._clients.put( client.toString(), client );
        if ( salle != null ) {
           if ( !this._rooms.containsKey( room.getName() ) ) {
             this._rooms.put( room.getName(), room );
           }
           room.addClient( client );
        }
     }
   }
   // Retire le client de la liste et des salles
   public void removeClient( Client client ) {
     synchronized( this ) {
       if ( client.getRoom() != null ) {
           client.getRoom().removeClient( client );
           client.setRoom( null );
       }
       this._clients.remove( client.getName() );
     }
   }

Voici un exemple d'implémentation pour manipuler la géolocalisation ...

Bon je me suis un peu renseigné concernant les systèmes experts. Il semblerait globalement qui soit conçu pour répondre à une question donné, et ainsi faire de l'aide à la décision.

Concrètement qu'est-ce qu'est censé faire ton système ?

10/05/2007, 11h23
minette

merci je vais tester ton code.

pour mon system en gros c'est avoir un fichier de regle qui va manipuler mes données par des interfaces.

Cela m'evitera d'avoir des structure IF .... Then trop complexe, et permettra de modifier simplement le fichier de regle.-