Flame Maker – Etape 3 – Dessinateur Flame

Les classes à écrire pour cette étape sont très similaires aux classes écrites pour l'étape précédente. Pour gagner du temps, il est donc souvent judicieux de s'inspirer de ces dernières. Toutefois, les classes de ces deux étapes sont indépendantes et aucune tentative ne sera faite de les lier entre-elles par des relations d'héritage, par exemple.

La classe abstraite Variation du paquetage ch.epfl.flamemaker.flame modélise les variations. Une variation étant une transformation, cette classe implémente l'interface Transformation de l'étape 1.

Les variations sont nommées et indexées, et la classe Variation possède donc deux champs privés et non modifiables. Le premier, de type int, contient l'indice de la variation. Le second, de type String, contient son nom. Le constructeur de la classe Variation prend ces deux valeurs en argument et les stocke dans les champs correspondants.

Chacune des six variations définies ci-dessus est placée dans une sous-classe concrète de la classe Variation. Il serait bien entendu possible de nommer les classes représentant les différentes variations. Toutefois, étant donné que seule une instance de ces classes est nécessaire, il est plus élégant d'utiliser des classes imbriquées anonymes.

Ces instances uniques des différentes variations doivent être stockées dans le champ public statique et non modifiable ALL_VARIATIONS de la classe Variation. Ce champ est une liste de variations, et chaque variation doit être à la position correspondant à son index. Par exemple, la variation Linear a l'indice 0 et doit donc se trouver à la position 0 de la liste.

En résumé, la classe Variation a la structure suivante :

public abstract class Variation implements Transformation {
    private final String name;
    private final int index;

    private Variation(int index, String name) { /* … */ }

    public String name() { /* … */ }
    public int index() { /* … */ }

    abstract public Point transformPoint(Point p);

    public final static List<Variation> ALL_VARIATIONS =
        Arrays.asList(new Variation(0, "Linear") {
                public Point transformPoint(Point p) {
                    // …
                }
            },
            // …
            );
}

La méthode statique asList de la classe Arrays prend un nombre variable d'arguments et retourne une liste non modifiable avec les éléments reçus. La méthode garantit que cette liste offre un accès en O(1) à n'importe lequel de ses éléments.

La classe FlameTransformation du paquetage ch.epfl.flamemaker.flame modélise une transformation Flame, c'est-à-dire la composition pondérée d'une transformation affine avec plusieurs variations. Comme il s'agit d'une transformation, elle implémente l'interface Transformation définie lors de la première étape.

Cette classe possède deux champs privés et non modifiables. Le premier, de type AffineTransformation contient la composante affine de la transformation. Le second, de type double[], est le tableau des poids des différentes variations.

FlameTransformation est équipée d'un seul constructeur public :

• FlameTransformation(AffineTransformation affineTransformation, double[] variationWeight), qui construit une transformation Flame composée de la transformation affine et des poids donnés. Le tableau des poids doit absolument être copiée par le constructeur (au moyen de la méthode clone), pour garantir l'immuabilité de la transformation. Lève l'exception IllegalArgumentException si le tableau de poids n'a pas la bonne taille.

Finalement, la classe FlameTransformation est équipé d'une unique méthode, transformPoint, qui est celle de l'interface Transformation. Comme d'habitude, cette méthode transforme le point passé en argument, d'après la formule donnée plus haut.

La classe Flame du paquetage ch.epfl.flamemaker.flame, très similaire à la classe IFS de l'étape précédente, modélise les fractales Flame. Elle est équipée d'un seul champ privé et non modifiable de type List<FlameTransformation> contenant les transformations caractérisant la fractale.

La classe Flame possède un unique constructeur public :

• Flame(List<FlameTransformation> transformations), qui construit une fractale Flame étant donné sa liste de transformations. La liste de transformation doit absolument être copiée par le constructeur, pour garantir l'immuabilité de la fractale.

Elle est de plus équipée d'une unique méthode publique :

• FlameAccumulator compute(Rectangle frame, int width, int height, int density), qui calcule la fractale dans la région du plan délimitée par le cadre frame et stocke le résultat dans un nouvel accumulateur de largeur width et de hauteur height, qui est retourné. Le nombre d'itérations à effectuer est calculé de la même manière que précédemment, c-à-d en multipliant les paramètres width, height et density.

L'accumulateur utilisé pour l'étape précédente était très simple et n'enregistrait qu'une information booléenne pour chaque case. Pour cette étape, un accumulateur capable de compter le nombre de points de la fractale contenus dans chaque case est utilisé.

Comme pour l'étape précédente, la représentation de l'accumulateur est répartie sur deux classes : la première, FlameAccumulator, est non modifiable ; la seconde, FlameAccumulator.Builder, est un bâtisseur permettant de construire un accumulateur en plusieurs étapes.

La classe FlameAccumulator possède l'unique constructeur privé suivant :

• FlameAccumulator(int[][] hitCount), qui construit un accumulateur avec le tableau bi-dimensionnel hitCount donné. Ce tableau doit absolument être copié en profondeur par le constructeur afin de garantir l'immuabilité de l'accumulateur.

Contrairement au constructeur de IFSAccumulator, qui était public, ce constructeur peut être privé car dans cette étape la classe du bâtisseur (Builder) est imbriquée à l'intérieur de la classe FlameAccumulator. Rendre le constructeur privé garantit que le seul moyen de construire un accumulateur est de passer par un bâtisseur.

La classe FlameAccumulator est équipée des méthodes publiques suivantes :

• int width(), qui retourne la largeur (en nombre de cases) de l'accumulateur.
• int height(), qui retourne la hauteur (en nombre de cases) de l'accumulateur.
• double intensity(int x, int y), qui retourne l'intensité de la case de l'accumulateur aux coordonnées données. L'intensité est calculée au moyen de la formule logarithmique décrite ci-dessus. A noter que le dénominateur de cette formule est constant et doit, pour des raisons de performance, être calculé à la construction de la classe et stocké dans un champ privé et non modifiable. Lève l'exception IndexOutOfBoundsException si l'une des deux coordonnées est invalide.

La classe FlameAccumulator.Builder, imbriquée (statiquement) dans la classe FlameAccumulator, modélise le bâtisseur d'accumulateur. Elle est équipée d'un seul constructeur public :

• Builder(Rectangle frame, int width, int height), qui construit un bâtisseur d'accumulateur pour la région du plan délimitée par le cadre frame, de largeur width et de hauteur height (en nombre de cases). Lève l'exception IllegalArgumentException si la largeur ou la hauteur n'est pas strictement positive (c-à-d supérieure à zéro).

Cette classe possède de plus les méthodes publiques suivantes :

• void hit(Point p), qui incrémente le compteur de la case correspondant au point p donné. Ne fait rien si le point est en dehors du cadre de l'accumulateur (c-à-d le paramètre frame passé au constructeur).
• FlameAccumulator build(), qui retourne un accumulateur contenant les points collectés jusqu'à présent.