Paramètres utilisateur
Etape 8

Lors de l'étape 5, les sept paramètres nécessaires au calcul d'un panorama ont été présentés. Pour mémoire, il s'agit de :

1. la position de l'observateur \(O\),
2. l'altitude de l'observateur \(e\),
3. l'azimut du centre du panorama \(a\),
4. l'angle de vue horizontal \(v_h\),
5. la distance maximale de visibilité \(d\),
6. la largeur du panorama \(w\),
7. la hauteur du panorama \(h\).

Tous ces paramètres seront modifiables au travers de l'interface graphique du programme final, au détail près que la position de l'observateur sera en réalité décrite par deux paramètres distincts : la longitude et la latitude de l'observateur.

Un paramètre supplémentaire sera ajouté à cette liste : le facteur de suréchantillonnage, décrit à la section 1.2 plus bas. Comme ce facteur n'influence le calcul du panorama que de manière indirecte, il n'a pas été nécessaire de l'inclure dans les paramètres définis à l'étape 5.

Bien entendu, les valeurs acceptables pour ces différents paramètres sont limitées. Par exemple, l'angle de vue horizontal ne peut être supérieur à 360°. De plus, même si notre programme gère théoriquement une position arbitraire de l'observateur, il est préférable de ne laisser l'utilisateur choisir qu'une position qui soit dans les limites des modèles du terrain à notre disposition.

Finalement, les unités à utiliser pour ces différents paramètres varient. S'il est par exemple sensé de permettre à l'utilisateur de spécifier l'atitude d'observation en mètres, la distance maximale de visibilité s'exprime plus naturellement en kilomètres. De même, des angles exprimés en degrés sont beaucoup plus naturels pour un être humain que des angles exprimés en radians.

La table ci-dessous résume les neuf paramètres décrivant un panorama et que l'interface graphique permettra de modifier, ainsi que leurs unités et valeurs limites autorisées, choisies en fonction des considérations qui précèdent.

Tous ces paramètres sont représentés par des valeurs entières, ce qui offre pour presque tous une précision suffisante à nos besoins. La seule exception est bien entendu la position de l'observateur, pour laquelle une précision d'un degré est nettement insuffisante — pour mémoire, un degré correspond à une distance d'environ 100 km à l'équateur.

Pour résoudre ce problème, nous stockerons la longitude et la latitude de l'observateur en dix-millième de degrés (1°/10 000), toujours sous forme entière. Dans l'interface utilisateur, ces valeurs seront toutefois présentées en degrés, avec exactement 4 décimales.

Cette petite astuce nous permet d'obtenir à la fois la précision souhaitée pour la position de l'observateur (environ 10 m), et une représentation entière de tous les paramètres.

Jusqu'à présent, nous avons fait l'hypothèse qu'à chaque point d'un panorama correspond exactement un pixel de l'image de ce même panorama. Toutefois, pour obtenir des images de meilleure qualité, il est préférable de combiner plusieurs points du panorama pour produire un seul pixel de l'image finale, technique que l'on nomme suréchantillonnage (supersampling).

Il existe de nombreuses techniques de suréchantillonnage, mais celle que nous utiliserons dans ce projet est la plus simple d'entre elles. Elle consiste à calculer et dessiner un panorama dont les dimensions (largeur et hauteur) sont le double ou le quadruple de celles de l'image finale, puis à redimensionner l'image obtenue. Lors de ce redimensionnement, la couleur de chaque pixel est obtenu par moyenne de la couleur de 4 ou 16 pixels voisins, ce qui produit une image de meilleure qualité.

Le degré de suréchantillonnage est spécifié par un paramètre nommé \(s\) et valant 0, 1 ou 2. Ce paramètre lie la largeur \(w_p\) et la hauteur \(h_p\) du panorama calculé et la largeur \(w_i\) et la hauteur \(h_i\) de l'image finale de la manière suivante :

L'image ci-dessous illustre l'effet du suréchantillonnage sur un extrait du panorama de l'introduction au projet. Cet effet est particulièrement visible aux alentours des crètes des montagnes, que le suréchantillonnage rend plus lisses.

Deux panoramas ont déjà été présentés dans les étapes précédentes, l'un des Alpes vues du Jura, l'autre du Niesen vu du lac de Thoune. La table ci-dessous rappelle leurs paramètres principaux (attention, l'angle de vue horizontal pour le Niesen a été augmenté !) et ceux de quatre autres panoramas prédéfinis que nous utiliserons ultérieurement.

Dans cette table, Az. est l'azimut \(a\) et AVH l'angle de vue horizontal \(v_h\).

L'énumération nommée p.ex. UserParameter, publique, énumère les neuf paramètres utilisateur mentionnés plus haut :

1. longitude de l'observateur (OBSERVER_LONGITUDE),
2. latitude de l'observateur (OBSERVER_LATITUDE),
3. altitude de l'observateur (OBSERVER_ELEVATION),
4. azimut central (CENTER_AZIMUTH),
5. angle de vue horizontal (HORIZONTAL_FIELD_OF_VIEW),
6. distance maximale de visibilité (MAX_DISTANCE),
7. largeur du panorama (WIDTH),
8. hauteur du panorama (HEIGHT),
9. exposant de suréchantillonnage (SUPER_SAMPLING_EXPONENT).

A chacun de ces paramètres sont attachées les valeurs minimales et maximales, données dans la table plus haut, dans l'unité correspondante. Ainsi, les valeurs minimales et maximales attachées à OBSERVER_LONGITUDE sont 60000 et 120000, et correspondent à 6° et 12°.

Les membre de l'énumération offrent une méthode publique nommée p.ex. sanitize, prenant en argument une valeur correspondant au paramètre qu'ils représentent, et retournant la valeur valide la plus proche. Par exemple :

int saneLon1 =                  // vaut 70000
  UserParameter.OBSERVER_LONGITUDE.sanitize(7_0000);
int saneLon2 =                  // vaut 120000
  UserParameter.OBSERVER_LONGITUDE.sanitize(20_0000);

Sachez qu'en Java les énumérations peuvent posséder des attributs, des méthodes et un constructeur (privé uniquement). L'exemple ci-dessous, dont vous pouvez vous inspirer, illustre la syntaxe :

public enum Season {
  SPRING("printemps"),
  SUMMER("été"),
  AUTUMN("automne"),
  WINTER("hiver");

  private String frenchName;
  private Season(String frenchName) {
    this.frenchName = frenchName;
  }

  public String frenchName() {
    return frenchName;
  }
}

La classe nommée p.ex. PanoramaUserParameters, publique et immuable, représente les paramètres d'un panorama du point de vue de l'utilisateur final de l'application. En gros, elle stocke la valeur des neuf paramètres décrits à la section 1.1, sous forme d'entiers exprimés dans l'unité qui leur correspond.

Etant donné que la totalité de ces paramètres ont une valeur entière, il est possible de les stocker dans une table associative, associant à chaque valeur de l'énumération UserParameter la valeur du paramètres correspondant. Cela simplifie grandement l'écriture de la classe PanoramaUserParameters et est donc fortement conseillé.

Notez au passage que s'il est bien entendu possible d'utiliser une table de type HashMap ou TreeMap dans ce but, la bibliothèque Java offre également la classe EnumMap, spécialisée au cas où les clefs proviennent d'une énumération. Son utilisation n'est pas très différente de celle des autres tables associatives, mais sa construction est un peu complexe. L'exemple suivant l'illustre, et vous pouvez vous en inspirer :

Map<Season, String> germanSeasons =
  new EnumMap<>(Season.class);
germanSeasons.put(Season.SPRING, "Frühling");

La classe PanoramaUserParameters offre deux constructeurs :

1. le constructeur principal, prenant en argument une table associative associant à chaque valeur de l'énumération UserParameter la valeur du paramètre correspondant,
2. un constructeur secondaire, prenant ces paramètres sous la forme de neuf arguments individuels et ne faisant rien d'autre qu'appeler le premier constructeur.

Avant de stocker la valeur de chaque paramètre, ces constructeurs doivent les valider et, au besoin, les remplacer par la valeur valide la plus proche. Ce faisant, ils doivent tenir compte de la valeur maximale tolérée pour l'angle de vue vertical (170°) et de l'impact que cela peut avoir sur la hauteur du panorama, comme décrit plus haut.

En plus de ces constructeurs, la classe PanoramaUserParameters offre des méthodes donnant accès à la valeur des paramètres qu'elle stocke :

• une méthode nommée p.ex. get, prenant en argument une valeur de l'énumération UserParameter et retournant la valeur du paramètre correspondant,
• neuf méthodes nommées p.ex. observerLongitude, etc. et retournant la valeur du paramètre décrit par leur nom,

Finalement, la classe PanoramaUserParameters offre deux méthodes permettant d'obtenir les paramètres du panorama — de type PanoramaParameters, défini à l'étape 5 — correspondants aux paramètres utilisateur :

• une méthode, nommée p.ex. panoramaParameters, retournant les paramètres du panorama tel qu'il sera calculé,
• une méthode, nommée p.ex. panoramaDisplayParameters, retournant les paramètres du panorama tel qu'il sera affiché.

La différence entre ces deux méthodes est simplement que la première prend en compte le degré de suréchantillonnage et retourne donc des paramètres dans lesquels la largeur et la hauteur du panorama correspondent aux variables \(w_p\) et \(h_p\) de la section 1.2 ; la seconde méthode ne tient pas compte du suréchantillonnage et la largeur et la hauteur des paramètres qu'elle retourne correspondent donc aux variables \(w_i\) et \(h_i\) de cette même section.

Finalement la classe PanoramaUserParameters redéfinit les méthodes equals et hashCode afin que ses instances soient comparées de manière structurelle.

L'interface nommée p.ex. PredefinedPanoramas contient six champs statiques définissant les instances de PanoramaUserParameters correspondant aux panoramas prédéfinis décrits plus haut. Pour chacun d'entre eux, la largeur est fixée à 2500 échantillons, la hauteur à 800, la distance maximale à 300 km et le facteur de suréchantillonnage à 0.