Discussion :

[Trademark]

Bonjour à tous,

Je suis en train de coder une classe "Neighborhood" représentant un voisinage. Pour vous mettre dans le contexte voici à quoi elle ressemble:

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
public class Neighborhood implements Iterable
{ 
  ArrayList<Position> relativePosition;
 
  public Neighborhood(ArrayList<Position> pos)
  {
    relativePosition = pos.clone();
  }
 
  // x is the mark of the Neighborhood.
  // @returns The absolute neighborhood with the mark x.
  public Neighborhood getAbsolute(Position x)
  {
    ArrayList<Position> pos = new ArrayList<Position>();
    for(Position p : relativePosition)
      pos.add(new Position(x.getx() + p.getx(), x.gety() + p.gety()));
    return new Neighborhood(pos);
  }
 
  public Neighborhood getAbsolute(Position x, Predicate<Position> p)
  {
    ArrayList<Position> absolutePos = new ArrayList<Position>();
    for(Position pos : relativePosition)
      if(p.evaluate(pos))
        absolutePos.add(new Position(x.getx() + pos.getx(), x.gety() + pos.gety()));
    return new Neighborhood(absolutePos);
  }
 
  @Override
  public Iterator iterator() 
  {
    return new NeighborhoodIterator();
  }
 
  private class NeighborhoodIterator implements Iterator
  {
    private Iterator iter;
 
    public NeighborhoodIterator()
    {
      iter = relativePosition.iterator();
    }
 
    @Override
    public boolean hasNext() 
    {
      return iter.hasNext();
    }
 
    @Override
    public Position next() 
    {
      return (Position) iter.next();
    }
 
    @Override
    public void remove() 
    {
      iter.remove();
    }
 
  }
}

Il existe certain type de voisinage super connu comme ceux de Moore et Von Neumann. En connaissance de cause, qu'est-ce qui est le mieux entre créer une méthode static createMooreNeighborhood() dans la classe Neighborhood ou un héritage comme celui-ci:

Code :

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

1
2
3
4
5
6
7
class MooreNeighborhood extends Neighborhood
{
  public MooreNeighborhood()
  {
    // Initialisation  ...
  }
}

Dans ce dernier cas, il faudrait un peu modifier la première classe pour pouvoir faire l'appel à super dès le début et pouvoir modifier ensuite.

Pour moi un voisinage de Moore est un voisinage mais mon "intuition" me dit plutôt d'utiliser une méthode static create car on ne spécialise pas vraiment la classe Neighborhood.

Qu'en pensez-vous ?

Et plus généralement, dans quelles cas utilise t'on l'un plutôt que l'autre ? Et existe t'il des patterns qui vont bien dans ce genre de situation ?

[tchize_]

Quel est la différence entre un voisinage et un voisinage de moore?

Suivant la réponse, la solution sera soit l'héritage, soit la création de plusieurs constructeur.

[Adpar]

Personnellement, dans la logique de ce que j'ai compris je verrai bien de l'héritage ici.
Après il faut bien sûr qu'il y ait une différence entre le voisinage Moore et le voisinage en général, que Moore ait une particularité. Sinon je ne vois pas l'intérêt.

[Trademark]

Ce que j'appelle un voisinage, c'est un ensemble de coordonnées. Si on veut calculer les coordonnées des voisins d'une coordonnées (x,y), alors il suffit d'additionner x et y à chacune des coordonnées du voisinage pour obtenir autant de nouveaux points.

Le voisinage de Moore, c'est simplement ça: http://en.wikipedia.org/wiki/File:Moore_d.gif

On pourrait imaginer des voisinages qui ne sont pas "logique" c'est à dire, juste le nord, ou encore l'est mais où la distance entre le centre et le voisin est de 4, etc.

Donc, à priori, un voisinage de Moore n'ajoute pas de membre à la classe, c'est juste une configuration spécifique.

[Adpar]

Je pense dans ce cas là que j'irai plus vers la construction de plusieurs constructeurs.

[Trademark]

Je ne vois pas comment faire ça en Java. J'ai juste une simple idée de faire comme ceci:

Code :

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

1
2
3
4
5
6
7
  public Neighborhood(ArrayList<Position> pos){
//...
}
 
// Si type = "Moore" alors un voisinage de Moore est créé
// Si type = "...
public Neighborhood(String type)

Mais je ne trouve pas ça très élégant, comment faire ?

[LittleBean]

Bonjour,

Quelle est la différence entre Neighborhood et une liste de Position ?

Si tu comptes exposer Neighborhood en iterable c'est que le comportement va être en dehors de ta classe, non ?

Dans ce cas pourquoi ne pas simplement faire des méthodes utilitaires qui créent ta liste de points :

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
public class Utils {
 
	Iterable<Position> getMoor(Position p){
		List<Position> l = new ArrayList<Position> ();
		l.add(new Position(p.getx()+1,p.gety()+1));
		// ...
		return l;
	}
 
	Iterable<Position> getVonNeumann(Position p){
		List<Position> l = new ArrayList<Position> ();
		l.add(new Position(p.getx()+1,p.gety()+1));
		// ...
		return l;
	}
 
	// autre
 
}

Si tu tiens absolument à faire un objet Neighborhood, c'est peut être que tu veux qu'il ait un comportement particulier. Dans ce cas il vaut mieux ne pas le faire itérable.

Pour décider si tu fais un héritage ou des méthode utilitaire de construction.
Il faut se poser la question est ce que je vais redéfinir un comportement dans le cas de mon voisinage de More ?

Par exemple,si tu as une méthode voisinageDuVoisinage dans Neighborhood.
Est ce que ce voisinage sera de même type que celui sur le quel tu l'appel ?
Si oui => héritage.

Ceci ne reste que mon humble opinion... et est parfaitement discutable

[Adpar]

Sinon, tu peux utiliser le pattern factory.

En clair, si tu tombes sur un type style Moore ou autre cas particulier tu crées un voisinages Moore, sinon si le type n'est pas connu comme particulier alors tu crées le voisinage par défaut.

[Trademark]

Merci à tous pour vos réponses mais je reste tout de même dubitatif.

Je ne peux pas faire de méthodes utilitaires comme l'a suggéré LittleBean car les voisins ne sont pas connus à la compilation. C'est en fait l'utilisateur qui défini les règles, dont une qui est de choisir les positions qu'il considère comme voisines à une autre.

Dans certain cas, l'utilisateur ne peut pas choisir cette règle car la famille de règles concernée ne l'autorisent pas (et dans ce cas, elle utilise bien souvent le voisinage de Moore ou Von Neumman, et donc le but est de factoriser ces traitements car plusieurs famille de règle devront construire ce type de voisinage). C'est dans ce cas que j'aurais aimé utiliser des fonctions utilitaires pour créer le voisinage.

Pour vous mettre dans le contexte, l'algorithme doit itérer sur les voisins d'une case et effectuer des traitements par rapport à ces voisins. D'où l'idée que la classe Neighborhood est itérable.

Adpar, il n'y a pas de voisinage qui est considéré "par défaut"..

Voici un petit exemple, à partir d'une Position x et un voisinage n, afficher les positions des voisins de x:

Code :

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

1
2
3
4
for(Position x : n.getAbsolute(x))
{
  System.out.println(x.getx() + ", " + x.gety());
}

Je trouve que ce code est élégant, ce qui justifie amplement le fait d'encapsuler l'ArrayList<Position> dans une classe Neighborhood.

Au final, j'en suis toujours au même point, maintenant que ma question et le contexte sont placés, connaissez-vous une solution élégante pour permettre de construire des configurations de voisins pré-existante ?

[tchize_]

On va reprendre depuis le début car c'est très confus tout ça

1) quelles sont les méthodes de Neighborhood, quel comportement attends tu de cet objet, quel est son but (encapsuler les voisins d'un point donner, être juste un "calculateur", etc..?)
2) en quoi ces comportement se différencie-t-ils pour un moore et pour un VonNeumann

En fonction de ça on pourra t'aider. Sans ça, on ne peux que spéculer.

[Trademark]

1) quelles sont les méthodes de Neighborhood, quel comportement attends tu de cet objet, quel est son but (encapsuler les voisins d'un point donner, être juste un "calculateur", etc..?)

Il encapsule la différence de coordonnée entre un point et les voisins concernés. Son but est de, à partir d'une position, calculer les positions absolues des voisins de cette position.

2) en quoi ces comportement se différencie-t-ils pour un moore et pour un VonNeumann

C'est à la construction, disons que un voisinage de Moore ou de Von Neumann est une instance particulière de la classe Neighborhood et qui sera souvent utilisée dans le programme (car re-construire ces objets "à la main" est laborieux, à savoir initialiser 4 ou 8 points dans une ArrayList<Position>, d'où mon désir de factoriser).

Ma solution du moment c'est d'utiliser deux méthodes static Neighborhood createMooreNeighborhood() et createVonNeumannNeighborhood dans Neighborhood.

[tchize_]

il, a mon avis, il n'encapsule rien donc, c'est un simple calculateur.


Dans cas, une interface Neigboorhod, avec les différentes signatures, me semble être le plus approprié

Code :

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

1
2
3
4
public interface Neighboorhood {
   public Iterable<Position> getAbsolute(Position x); 
   public Iterable<Position> getAbsolute(Position x, Predicate<Position> p)
}

ensuite les implémentation

Code :

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

1
2
3
4
 
public MooreNeighboorhood  implements Neighboorhood {
.....
}

Code :

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

1
2
3
4
 
public VonNeumann implements Neighboorhood {
.....
}

et l'utilisation:

Code :

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

1
2
3
4
5
6
7
 
Neighboorhood n = new MooreNeighboorhood ();
Position source = .....;
for(Position x : n.getAbsolute(source))
{
  System.out.println(x.getx() + ", " + x.gety());
}

[Trademark]

Merci de ta réponse mais je n'ai pas du bien m'exprimer sur le sujet.

La fonction getAbsolutePosition sera identique pour Moore ou VonNeuman ou n'importe quelle voisinage qu'on peut inventer. Finalement un voisinage n'est qu'une liste de coordonnées sur lesquelles on applique un traitement pour retrouver les coordonnées réelles à partir d'un point ou d'un point et d'un prédicat.

C'est pour cette raison que j'ai opté pour ma première intuition, à savoir deux méthodes "build".

Finalement, la principale faiblesse de ce que tu énonces, tchize_, c'est qu'il faudra ré-implémenter une classe (et ce même si on factorise getAbsolutePosition dans une classe abstraite) à chaque fois que les coordonnées changeront. Ce qui dans mon cas n'est de toutes façons pas possibles vu que ces coordonnées sont choisies dynamiquement. Mais comme je l'ai dit, je m'étais probablement mal exprimé.

N'hésitez pas à me proposer et/ou me corriger sur cette implémentation, même si je place le sujet en résolu.