Simulateur de position : geolocalisation

**minette** · 03/05/2007, 13h16

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 :

**Logan Mauzaize** · 03/05/2007, 17h48

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
  }

**minette** · 04/05/2007, 09h25

Envoyé par Nemek

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Logan Mauzaize** · 04/05/2007, 10h15

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ;-)

**minette** · 04/05/2007, 13h02

merci, il y a encore quelque beug :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  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 :

**Logan Mauzaize** · 04/05/2007, 13h23

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...

Simulateur de position : geolocalisation

Langage Java

Vue hybride

Discussions similaires

Partager

Partager