Geomertrie Descriptive

Université Libre de Bruxelles
Faculté des Sciences Appliquées

Service des Systèmes Logiques et Numériques
Calcul et représentation de l’information de visibilité

pour l’exploration interactive de scènes tridimensionnelles
Denis H AUMONT
Promoteur
Nadine WARZ ÉE
Manuscrit présenté en vue de l’obtention du grade de

Docteur en Sciences Appliquées
Année 2006
2
Remerciements
Mes premiers remerciements vont à Nadine Warzée et à Philippe Van Ham, pour m’avoir per-
mis de réaliser cette thèse, pour leur encadrement et pour leur soutien continu. Toute ma gratitude va
également à Alain Hubrecht, pour avoir initié le projet, et pour l’avoir toujours soutenu lorsque cela
s’avérait nécessaire, ainsi qu’à Xavier Marichal, qui a accepté de le poursuivre, et sans qui l’aventure
aurait sans doute tourné court.
Je remercie ensuite l’ensemble des membres du jury, Philippe Bekaert, Philip Dutré, François Sil-
lion et Michaël Tolley, pour avoir accepté d’en faire partie et pour l’attention qu’ils ont porté à mes
travaux.
Mes remerciements vont également à tous les membres des équipes avec lesquelles j’ai eu la
chance de travailler. A tous les séléniens d’abord, pour ces cinq années passées ensemble. Aux équipes
d’Appeal, d’Alterface et de VRContext ensuite, pour avoir toujours aidé à recadrer mes travaux dans
le concret. Je pense plus particulièrement à Christophe Chaudy, formidable professeur (malgré lui !),
qui a su guider mes premiers pas de doctorant, et à Flavien Brébion. A l’ensemble de l’équipe Artis
finalement, pour leur accueil durant l’hiver 2002. Une mention toute particulière à François Sillion
pour ses conseils avisés, ses réflexions lumineuses, et pour m’avoir emmené à la découverte de pay-
sages scientifiques insoupçonnés.
J’aimerais aussi remercier mes compagnons de labeur, Shaun Nirenstein, Otso Mäkinen, Xavier
Décoret et Olivier Debeir, pour la qualité de leur travail, leur enthousiasme et pour les discussions
toujours fructueuses que nous avons partagées, et sans qui aucune publication n’aurait pu voir le jour.
Longue vie au précalcul de visibilité.
Je remercie mes parents, pour leurs précieuses relectures, mais surtout pour leur soutien en toutes
circonstances. Merci aussi à Claire et à toute la famille pour leurs encouragements.
C’est grâce aux amis, Frédéric, Bénédicte, Dominique, Clara, Jean-François, Stéphane, Sophie,
Anthony, Caroline, Marco, Cédric, Christophe, Virginie et tous les autres, que je ne me suis pas tout à
fait transformé en rat de laboratoire. Qu’ils en soient remerciés.
Enfin, puisque l’on garde en général le meilleur pour la fin, je ne remercierai jamais assez Carole,
dont l’aide et les encouragements n’ont eu d’égal que la patience, et à qui je dédie ce document.
T a b l e d e s m a t i è r e s
1 Introduction 9
1 Synthèse interactive d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Visualisation interactive de scènes complexes . . . . . . . . . . . . . . . . . . . . . 10
2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Aperçu des solutions existantes . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Elimination des surfaces non visibles . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1 Méthode classique du <z-buffer> . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Méthodes d’<occlusion culling> . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.1 <Occlusion culling> en ligne . . . . . . . . . . . . . . . . . . . . 14
3.2.2 <Occlusion culling> avec précalcul . . . . . . . . . . . . . . . . . 14
3.2.3 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4 Objectifs de notre étude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5 Plan de la thèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Outils mathématiques 19
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2 Introduction aux polyèdres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1 polyèdres et polytopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Faces d’un polyèdre et description combinatoire . . . . . . . . . . . . . . . 21
2.3 Graphe d’incidence et 1-squelette . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Complexe de polyèdres et arrangement d’hyperplans . . . . . . . . . . . . . 22
2.5 Graphe dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Espace dual et coordonnées de Plücker . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.1 Représentation d’une droite dans un espace dual . . . . . . . . . . . . . . . 24
3.2 Coordonnées de Plücker . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.2 Définition mathématique des coordonnées de Plücker . . . . . . . 27
3.2.3 Coordonnées de Plücker dans R2 [23] . . . . . . . . . . . . . . . . 28
3.2.4 Coordonnées de Plücker dans R3 . . . . . . . . . . . . . . . . . . 30
3 Etat de l’art 33
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2 Visibilité analytique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.1 Graphe d’aspect et partition <VSP> . . . . . . . . . . . . . . . . . . . . . . 35
2.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.1.2 Frontières entre régions d’aspect constant . . . . . . . . . . . . . 36
4 TABLE DES MATIÈRES
2.1.3 Description des surfaces critiques . . . . . . . . . . . . . . . . . . 37

2.1.4 Utilisation du graphe d’aspect pour le calcul de vues . . . . . . . . 41
2.2 La structure de données <Asp> . . . . . . . . . . . . . . . . . . . . . . . . 41
2.3 Arrangement d’hyperplans dans l’espace de Plücker . . . . . . . . . . . . . 42
2.4 Méthodes de visibilité globales . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.4.1 Complexe de visibilité . . . . . . . . . . . . . . . . . . . . . . . . 43
2.4.2 Squelette de visibilité . . . . . . . . . . . . . . . . . . . . . . . . 44
2.5 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3 Encodage de la visibilité sous la forme de <PVS> . . . . . . . . . . . . . . . . . . . 46
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2 Algorithmes de visibilité depuis une région . . . . . . . . . . . . . . . . . . 48
3.2.1 Techniques conservatives . . . . . . . . . . . . . . . . . . . . . . 48
3.2.2 Techniques agressives . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.3 Techniques exactes . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.3 Partition de l’espace navigable en cellules . . . . . . . . . . . . . . . . . . . 55
3.3.1 Partitions utilisées pour encoder les <PVS> . . . . . . . . . . . . 56
3.4 Stockage de <PVS> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.5 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4 Encodage de la visibilité sous la forme de graphes cellules-portails . . . . . . . . . . 60
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.2 Génération automatique de graphes cellules-portails . . . . . . . . . . . . . 61
4.3 Détermination des objets masqués à partir d’un graphe cellules-portails . . . 62
4.4 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4 Requête exacte d’occultation entre deux polygones 65

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.1 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
1.2 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.1 Principes généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.2 Ensemble des droites poignardant deux polygones . . . . . . . . . . . . . . 69
2.3 Découpe de polyèdres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
2.4 Calcul exact de visibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3 Algorithmes basés sur le 1-squelette des polytopes dans l’espace de Plücker . . . . . 71
3.1 Algorithme de découpe de polytopes à d dimensions . . . . . . . . . . . . . 71
3.2 Construction de l’ensemble des droites poignardant deux polygones 3D . . . 73
3.2.1 Principe général . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.2.2 Description de l’algorithme . . . . . . . . . . . . . . . . . . . . . 75
3.2.3 Comparaison avec l’état de l’art . . . . . . . . . . . . . . . . . . . 76
3.3 Complexité théorique des algorithmes . . . . . . . . . . . . . . . . . . . . . 76
4 Requête simple et efficace d’occultation entre deux polygones . . . . . . . . . . . . 78
4.1 Sélection des écrans guidée par la visibilité . . . . . . . . . . . . . . . . . . 78
4.2 Agrégation des écrans basée sur leur silhouette étendue . . . . . . . . . . . . 79
4.3 Algorithme pour une requête d’occultation analytique entre deux polygones . 82
4.4 Analyse de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.5 Relation entre l’algorithme de soustraction et la visibilité analytique . . . . . 84
4.5.1 Dans R2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
TABLE DES MATIÈRES 5
4.5.2 Dans R3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.1 Evaluation des performances de l’algorithme . . . . . . . . . . . . . . . . . 88
5.1.1 Description des scènes de test . . . . . . . . . . . . . . . . . . . . 88
5.1.2 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.1.3 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.1.4 Comparaison avec l’état de l’art . . . . . . . . . . . . . . . . . . . 91
5.2 Sélection des écrans et détection des ouvertures . . . . . . . . . . . . . . . . 92
6 Conclusion et perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5 Précalcul de visibilité depuis les objets 97

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
1.1 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
1.2 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.1 Visibilité encodée au niveau des objets . . . . . . . . . . . . . . . . . . . . . 99
2.2 Ecrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
3 Principe de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.1 Représentation des volumes d’ombre . . . . . . . . . . . . . . . . . . . . . 101
4.2 Choix des écrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.2.1 Précalcul de visibilité . . . . . . . . . . . . . . . . . . . . . . . . 104
4.3 Calcul de visibilité en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.3.1 Localisation de la caméra au sein de la capsule . . . . . . . . . . . 105
4.3.2 Cohérence temporelle . . . . . . . . . . . . . . . . . . . . . . . . 106
5 Compression de l’information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6 Résultats et discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.1 Description des scènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.2 Evaluation de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.2.1 Analyse du facteur d’accélération . . . . . . . . . . . . . . . . . . 110
6.2.2 Augmentation du facteur d’accélération . . . . . . . . . . . . . . 113
6.3 Comparaison avec des PVS . . . . . . . . . . . . . . . . . . . . . . . . . . 113
6.3.1 Comparaison qualitative de la sur-conservativité . . . . . . . . . . 114
6.3.2 Efficacité pour l’<occlusion culling> . . . . . . . . . . . . . . . . 114
6.3.3 Occupation mémoire . . . . . . . . . . . . . . . . . . . . . . . . 116
7 Conclusion et travail futur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.1 Ecrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.2 Encodage hiérarchique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.3 Application au calcul de <PVS> . . . . . . . . . . . . . . . . . . . . . . . . 119
6 Création volumique de graphes cellules-portails 123

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
1.1 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
1.2 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2.1 Génération de graphes cellules-portails . . . . . . . . . . . . . . . . . . . . 125
2.2 <Watershed> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
2.3 Champ de distances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

2.3.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
2.3.2 Calcul de champs de distances . . . . . . . . . . . . . . . . . . . 126
2.3.3 <Adaptively Sampled Distance Fields> (<ADF>) . . . . . . . . . 127
3 Génération automatique de graphes cellules-portails . . . . . . . . . . . . . . . . . . 127
3.1 Présentation de l’algorithme de <watershed> . . . . . . . . . . . . . . . . . 127
3.2 Utilisation du <watershed> pour la génération de graphes cellules-portails . . 128
4 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.1 Etape 1 : Calcul du champ de distances . . . . . . . . . . . . . . . . . . . . 131
4.2 Etape 2 : Détection des portails . . . . . . . . . . . . . . . . . . . . . . . . 131
4.3 Etape 3 : Création des portails . . . . . . . . . . . . . . . . . . . . . . . . . 132
4.3.1 Positionnement basé sur le champ de distances . . . . . . . . . . . 133
4.3.2 Positionnement basé sur un procédé d’analyse d’images . . . . . . 134
4.3.3 Taille du portail . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.4 Etape 4 : Création des cellules . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.4.1 Localisation de la caméra . . . . . . . . . . . . . . . . . . . . . . 135
5 Implémentation hiérarchique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
6 Sur-segmentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.1 Elimination des détails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.2 Voxelisation robuste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
7 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
7.1 Etude qualitative des graphes générés . . . . . . . . . . . . . . . . . . . . . 138
7.2 Statistiques concernant la génération des graphes . . . . . . . . . . . . . . . 142
7.3 Utilisation du <CPG> pour l’<occlusion culling> . . . . . . . . . . . . . . . 142
8 Conclusions et perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
7 Conclusions et perspectives 145

TABLE DES MATIÈRES 7
Notations
Rd Espace réel à d dimensions
Pdo Espace projectif orienté à d dimensions
P(x1 ; :::; xd ) Point de Rd

l Droite, demi-droite ou segment de droite
H Hyperplan
v(X1 ; :::) Vecteur
< v; v > Produit scalaire
jjvjj Norme euclidienne du vecteur v
P Polyèdre de Rd
S Squelette d’un polytope
C Complexe de polytopes
Vi Sommet d’un polytope
A[Vm ; Vn ] Arête d’un polytope reliant les sommets Vm à Vn
Qi <Polyèdre> courbe, intersection du polyèdre Pi et de la quadrique de Plücker
L Point dans l’espace dual des droites, dual de la droite l

Hl (x) Hyperplan de l’espace des droites, dual de la droite l
v Vecteur dans l’espace dual des droites
fA1 A2; ; :::; An g Ensemble de n éléments Ai

j j Cardinal d’un ensemble
O() Complexité d’un algorithme

Introduction
chapitre 1
Sommaire
1 Synthèse interactive d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Visualisation interactive de scènes complexes . . . . . . . . . . . . . . . . . . . 10
2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Aperçu des solutions existantes . . . . . . . . . . . . . . . . . . . . . . . 11
3 Elimination des surfaces non visibles . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1 Méthode classique du <z-buffer> . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Méthodes d’<occlusion culling> . . . . . . . . . . . . . . . . . . . . . . . 12
4 Objectifs de notre étude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5 Plan de la thèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1 Synthèse interactive d’images

La synthèse d’images, qui consiste à développer des algorithmes pour générer des images à l’aide
d’un ordinateur, est devenue incontournable dans de nombreuses disciplines. Nous pensons d’abord
aux domaines scientifiques, où les images de synthèse permettent de visualiser des phénomènes com-
plexes (écoulements turbulents, plasmas), des objets de très grande taille (surface d’une planète,
galaxie), ou au contraire très petits (molécules, cellules), des phénomènes très lents (croissance de
végétaux ou de cristaux) ou des lieux dangereux (intérieur d’un réacteur nucléaire). C’est grâce aux
technologies de visualisation qu’il est désormais possible de visiter l’intérieur du corps d’un patient
sans devoir pratiquer la moindre incision, ou encore d’opérer un malade à distance. Le secteur in-
dustriel en général, et automobile en particulier, a toujours été un acteur important dans le domaine
de l’infographie, car il a exploité ces techniques pour la création à très faibles coûts de maquettes.
Aujourd’hui, on n’imagine plus la conception de pièces mécaniques sans leur visualisation à l’aide
d’un ordinateur. Il en est de même en architecture et en urbanisme, où la création d’un bâtiment
ou la rénovation d’un quartier passent par une représentation virtuelle du projet. Même les indus-
tries pétrolière et pharmaceutique sont aujourd’hui consommatrices d’images virtuelles, l’une pour
découvrir les gisements, l’autre pour créer de nouvelles molécules. Si le domaine éducatif n’est pas
en reste, avec par exemple les simulateurs d’entraı̂nement ou encore les visites virtuelles de musées
et de sites archéologiques, les applications les plus connues du grand public sont certainement celles
liées au divertissement. Publicité et cinéma utilisent les techniques les plus avancées pour leurs effets
spéciaux, et il existe aujourd’hui des films entièrement réalisés en images de synthèse. Ce panorama
10 chapitre 1. Introduction
serait évidemment incomplet si nous n’évoquions pas le secteur des jeux vidéo, qui utilisent les images
de synthèse afin d’immerger le joueur au sein de vastes mondes imaginaires.
Parmi toutes les applications que nous venons de décrire, on peut distinguer deux types de navi-
gation : les méthodes non-interactives et les méthodes interactives1 . Celles de la première catégorie
calculent des séquences d’images, chacune d’elles pouvant éventuellement nécessiter un très long
temps de calcul, que l’on regarde ensuite à la manière d’un film. Les méthodes interactives procèdent
d’une autre philosophie : les images sont générées au fur et à mesure, compte tenu des sollicitations
de l’utilisateur, qui peut interagir avec l’environnement virtuel. L’utilisateur est entièrement libre de
ses mouvements, et l’affichage des images doit être effectué à une cadence suffisamment élevée pour
donner une impression de continuité et d’immersion (25 images par seconde constituent le standard).
Sous la pression de l’industrie du jeu vidéo, le matériel graphique a subi une évolution extrêmement
rapide au cours de la dernière décennie, et ses performances ont décuplé. Entraı̂née par ce progrès,
l’interactivité est sortie du domaine des jeux vidéo et des simulateurs d’entraı̂nement, et a envahi tous
les domaines d’applications, tendant à faire disparaı̂tre les méthodes non-interactives.
Cependant, malgré les progrès réalisés par le matériel, de nouveaux besoins supplantent toujours
les capacités de traitement. Nous nous sommes donc attaché à rechercher des algorithmes d’affi-
chage, permettant de visualiser de manière interactive des scènes complexes, c’est-à-dire de mettre au
point des techniques d’accélération sans lesquelles la visualisation de ces modèles ne pourrait pas être
réalisée de cette manière.
2 Visualisation interactive de scènes complexes

2.1 Motivation
La recherche d’algorithmes pour l’affichage de scènes complexes est motivée par le fait que la
quantité de données à afficher augmente plus rapidement que la puissance de traitement. Les raisons
en sont multiples. D’une part, les utilisateurs sont en contact permanent avec les images de synthèse,
et deviennent plus exigeants au fur et à mesure qu’ils se familiarisent avec cette technologie. Pour
répondre à leurs attentes, il est nécessaire d’augmenter sans cesse la qualité des images produites, le
but ultime étant la production d’images photo-réalistes, que l’on ne peut distinguer de photographies
réelles. Cette quête de réalisme est intimement liée à une augmentation de la taille des données, car
les scènes se doivent également d’être de plus en plus riches et détaillées ; l’immersion sera d’au-
tant meilleure que ces dernières sont vastes et qu’on n’en perçoit pas les limites. D’autre part, les
ensembles de données générés sont toujours plus volumineux. L’exemple récent de l’Airbus A380
illustre bien l’augmentation de complexité des projets d’ingénierie, le nombre de pièces à afficher
pour visualiser l’ensemble de l’avion n’ayant jamais été aussi élevé 2 . Il en est de même pour les
simulations scientifiques, qui produisent des solutions dont la résolution augmente avec les capa-
cités des calculateurs. Enfin l’augmentation de la taille des données est également renforcée par le
développement des méthodes automatiques d’acquisition, telles que le scanner 3D, ou les techniques
de modélisation à partir de séquences d’images.
1 Appelées plus communément méthodes <3D temps réel>.

2 Les modèles complexes actuels contiennent plusieurs centaines de millions de polygones [71].
3 Elimination des surfaces non visibles 11
2.2 Aperçu des solutions existantes

Pour visualiser des scènes complexes de manière interactive, à la fréquence de 25 images par se-
conde, il est souvent nécessaire de combiner plusieurs techniques.
Lorsque la capacité de la mémoire centrale est insuffisante pour contenir l’entièreté du modèle, les
données nécessaires à la génération de l’image doivent être amenées à la demande depuis la mémoire
de masse [68, 158, 42]. Si cette dernière n’est accessible que par le biais d’un réseau informatique, il
faut de plus gérer les temps de latence introduits par le canal de transmission [68, 67, 136], et utiliser
des techniques de compression pour transférer les données de manière efficace [123].
Une fois les données transférées en mémoire, une technique primordiale pour réduire leur volume est
d’utiliser un niveau de détail adéquat pour les afficher, en simplifiant par exemple les maillages des
objets lointains [163, 4, 29, 169].
Une autre possibilité consiste à utiliser, en lieu et place des maillages polygonaux initiaux, des repré-
sentations alternatives très rapides à afficher : des trompe-l’œil à base d’images appelés imposteurs
[108, 5, 80], des nuages de points [28, 34, 171, 90], des représentations volumiques [71, 46] ou encore
des primitives simples [135, 160]. D’autres techniques d’accélération consistent à réutiliser des par-
ties de l’image déjà calculées auparavant [141, 84] ; des visualisations recréées entièrement à partir
d’images ont même été proposées [164].
Lorsque la scène présente de nombreuses occultations, les objets se masquent mutuellement et une
accélération très importante de l’affichage peut être obtenue en éliminant les surfaces non visibles
depuis le point de vue de la caméra [54, 83, 35, 124, 18]. Les calculs redondants étant éliminés, le coût
de l’affichage devient proportionnel au nombre d’objets visibles dans l’image, et n’est donc plus pro-
portionnel à la taille de la base de données. En combinant plusieurs de ces techniques, les approches
récentes permettent de visualiser des ensembles de données contenant des centaines de millions de
primitives [4, 163, 42, 29, 71, 160].
Dans ce travail, nous avons choisi d’étudier en particulier une de ces problématiques : celle de
l’élimination efficace des surfaces non visibles. Comme nous allons le voir dans la section suivante,
ce choix est guidé par le fait que ces méthodes permettent de s’affranchir de la taille des modèles,
en rendant la vitesse d’affichage sensible au nombre de primitives géométriques visibles depuis la
caméra, plutôt qu’au nombre total de primitives de la scène.
3 Elimination des surfaces non visibles

3.1 Méthode classique du <z-buffer>
Considérons l’image de synthèse obtenue avec une caméra virtuelle, observant une scène tridi-
mensionnelle. Seuls les objets visibles depuis le centre optique de la caméra y sont représentés. Pour
obtenir une représentation correcte de la scène, il a été nécessaire d’éliminer les faces cachées, en
déterminant quelles primitives de la scène sont visibles en chacun de ses pixels. L’élimination des
faces cachées, connue en anglais sous le nom de <hidden surface removal>, étant l’un des problèmes
fondamentaux en synthèse d’images, elle constitua un sujet de recherche très actif dans les années
1970 [63]. L’algorithme du <z-buffer> [27]3 a fini par s’imposer et est devenu un standard de fait, en
étant implanté dans le matériel graphique ; il est aujourd’hui utilisé universellement dans le domaine
de la 3D interactive.
3 Le <z-buffer> est parfois appelé <tampon de profondeur> en français.
Cet algorithme consiste à calculer, conjointement à l’image, une carte de profondeur appelée <z-
buffer>. Chacun des pixels du <z-buffer> contient la distance à la primitive la plus proche. Lors de
l’affichage d’une nouvelle primitive, la nouvelle profondeur de chacun des pixels qu’elle recouvre est
calculée et comparée à la profondeur stockée auparavant : la primitive visible en chacun des pixels
est celle dont la profondeur est la plus petite. L’élimination des surfaces masquées étant effectuée
au niveau du pixel, l’algorithme s’intègre naturellement dans le processus d’affichage par projection
de polygones (cf. Figure 1.1) : la profondeur des pixels se calcule directement lors de l’opération de
projection, l’ordre d’affichage des surfaces est quelconque, et la précision obtenue est celle du pixel.
F IG . 1.1: Processus d’affichage classique à l’aide de l’algorithme du <z-buffer>.

.
Cependant, cet algorithme possède également de nombreux désavantages. Tout d’abord, le proces-
sus de détermination intervient très tard dans le processus d’affichage, ce qui signifie que la surface,
qu’elle soit visible ou masquée, a déjà subi de nombreux traitements (transfert vers la carte graphique,
projection, <rasterization> 4 ). De plus, chacune des surfaces situées à l’intérieur du cône de vision
de la caméra doit être traitée. Pour ces raisons, un procédé d’élimination survenant en amont dans le
processus d’affichage est souhaitable : les primitives masquées sont éliminées plus tôt, à l’aide d’une
méthode dite d’<occlusion culling>.
3.2 Méthodes d’<occlusion culling>

Ces méthodes décomposent traditionnellement l’élimination des faces masquées en deux étapes
successives. Au cours de la première étape, une estimation grossière des objets masqués est effectuée
à l’aide de l’algorithme d’<occlusion culling>. Pour obtenir de bonnes performances, cette phase ne
fournit pas un résultat exact, mais plutôt un résultat prudent5 : seule une partie des objets masqués
est détectée, et un objet visible n’est jamais éliminé. L’ensemble des objets qui n’ont pas été éliminés
forment le <PVS> 6 , c’est-à-dire un ensemble de primitives potentiellement visibles, et contient
donc par construction l’ensemble des primitives visibles et éventuellement certaines primitives oc-
cultées. La détermination fine de la visibilité est effectuée dans un second temps, avec un algorithme
de <hidden surface removal> tel que le <z-buffer>, qui n’opère que sur les surfaces du PVS (cf. Fi-
gure 1.2). On appelle sur-conservativité la différence entre le nombre de primitives du PVS et le
nombre de primitives effectivement visibles (cf. Figure 1.3 (b)).
Comparativement à un algorithme de <hidden surface removal>, un algorithme d’<occlusion
culling> a une meilleure efficacité : par définition, sa complexité est liée au nombre d’objets vi-
sibles plutôt qu’au nombre total d’objets de la scène. Un algorithme d’<occlusion culling> est donc
sensible à la taille des données en sortie et non plus à la taille des données en entrée7 . D’une manière
processus de <rasterization> consiste à transformer la représentation vectorielle des primitives en un ensemble de
4 Le
pixels.
5 En anglais, on dit que l’algorithme est <conservative>.
6 <PVS> pour <Potentially Visible Set> en anglais.
7 En anglais, on dit que l’algorithme est <output sensitive>.
3 Elimination des surfaces non visibles 13
F IG . 1.2: Le processus d’<occlusion culling> élimine grossièrement les objets masqués et fournit un PVS.
Ensuite, un algorithme de <z-buffer> est utilis é pour déterminer précisément les surfaces visibles.
.
plus formelle, un algorithme d’<occlusion culling> est un algorithme de visibilité dont la complexité
pour le calcul d’une image est O(nv + f (nm )), avec nv le nombre de primitives visibles, nm le nombre
de primitives masquées, f une fonction telle que f (x) << x [151] (typiquement, f (x) sera du type
logarithmique).
La taille de la scène que l’on peut afficher en utilisant uniquement l’algorithme du <z-buffer> est
directement proportionnelle aux capacités du matériel graphique : on peut voir sur la Figure1.3 que
l’on ne pourra afficher de manière interactive que des scènes dont le nombre de polygones est inférieur
au point A 8 . Lorsqu’un algorithme d’<occlusion culling> est utilisé, cette limite est repoussée au point
B. Comme nous l’expliquerons dans la section 3.2.3, il existe potentiellement un point L en dessous
duquel l’algorithme du <z-buffer> est plus efficace que l’algorithme d’<occlusion culling>.
(a) (b)
F IG . 1.3: (a) Vitesse d’affichage d’une image en fonction du nombre de polygones de la sc ène dans le cas
d’une scène comportant de nombreuses occultations.(b) Nombre de polygones affich és en fonction du nombre
de polygones de la scène. L’échelle des axes n’est pas la même (le nombre de polygones par unit é de mesure de
l’échelle 1 est plus élevé que pour l’échelle 2, typiquement d’un facteur 10 à 100). En utilisant un algorithme
de <z-buffer>, le nombre de primitives affich ées et le temps de calcul sont proportionnels à la taille de la scène.
Au contraire, un algorithme d’<occlusion culling> permet d’obtenir un temps d’affichage li é au nombre de
primitives visibles dans l’image.
Les premières techniques d’<occlusion culling> furent proposées dès les années 1970 [33, 88,
110], et ont été à l’origine d’un très grand nombre de méthodes. Ces dernières sont séparées en deux
grandes classes [35] : les méthodes en ligne et les méthodes avec précalcul.
8 Les performances du matériel graphique actuel (2005) se situent aux alentours de 15 millions de polygones affichés
par seconde, soit un point A situé aux environs de 500 000 polygones.
3.2.1 <Occlusion culling> en ligne

Dans le cas des méthodes en ligne, les objets sont éliminés à la demande lors de la phase de naviga-
tion interactive. Etant donné que les calculs sont effectués au vol, ils doivent être très performants pour
qu’un gain de temps puisse être escompté. Pour ce faire, les algorithmes exploitent souvent différents
types de cohérence [74, 21] :
– la cohérence spatiale : deux objets voisins sont souvent masqués de manière simultanée. Les
primitives sont stockées dans une représentation arborescente, et les tests de visibilité sont ef-
fectués de manière hiérarchique afin d’éliminer des portions entières de la scène à l’aide d’un
seul test.
– la cohérence dans l’espace image : deux pixels voisins proviennent souvent de la même surface,
et ils peuvent être traités simultanément.
– la cohérence temporelle : si la vitesse de déplacement de l’utilisateur est limitée, la visibilité
change peu entre deux images successives et l’on peut réutiliser des résultats calculés à l’image
t pour l’image t + 1.
3.2.2 <Occlusion culling> avec précalcul

Le principe de ces méthodes consiste à effectuer les calculs d’occultation au cours d’une phase
de précalcul, à les stocker et à les réutiliser lors de la phase d’exploration interactive pour éliminer
les objets masqués depuis le point de vue courant [3]. L’information calculée devra permettre de
déterminer l’ensemble des objets visibles en tout point de l’espace. Cette stratégie, qui consiste à
échanger du temps de calcul contre de la mémoire de stockage, est classique en informatique, et
repose sur la supposition que l’exploitation de résultats stockés est plus efficace que le calcul à la
demande de l’information ex nihilo.
3.2.3 Discussion
Aucun des deux types de méthodes ne supplante l’autre : ils doivent plutôt être considérés comme
complémentaires, et le choix d’utiliser une technique en ligne ou une technique avec précalcul dépend
des conditions d’utilisation.
Le premier critère est celui des ressources disponibles, car déterminer les primitives occultées
demande une puissance de calcul considérable. Si les méthodes en ligne bénéficient des progrès des
cartes graphiques [17] et peuvent être optimisées [2], elles restent coûteuses en temps de calcul, et ne
seront pas utilisables dans certaines situations : architectures matérielles avec un processeur peu puis-
sant, processeur partagé entre différentes tâches (intelligence artificielle, diffusion de sons,...). Dans
ces cas, les techniques utilisant un précalcul seront mieux adaptées. Un exemple typique est celui d’un
jeu vidéo : le précalcul est effectué une seule fois, lors de la conception du produit, éventuellement
à l’aide d’une architecture informatique haut de gamme (grappe, super-calculateur,...). Ensuite, les
données sont utilisées par tous les utilisateurs, qui ne disposent souvent que de machines dont la puis-
sance serait insuffisante pour réaliser le calcul de visibilité pendant l’affichage de l’image. Le coût du
précalcul est donc amorti par un très grand nombre d’utilisations. Cependant, le temps nécessaire pour
effectuer le précalcul est élevé (typiquement de l’ordre de plusieurs heures, voire plusieurs jours), et
peut devenir prohibitif si l’on désire visualiser des données sans délai. Outre les contraintes de temps
de calcul, les méthodes avec précalcul nécessitent également une mémoire de stockage importante,
qui peut devenir critique si les scènes sont vastes. Cependant, cette contrainte est moins sévère que la
contrainte de temps de calcul, car il est possible de compresser l’information de visibilité [157] ; de
plus, une possibilité intéressante consiste à exploiter l’information de visibilité précalculée pour ne
4 Objectifs de notre étude 15
mettre en mémoire que la partie de la scène utile (ou proche de le devenir), et permettre de visualiser
des ensembles de données impossibles à stocker intégralement en mémoire centrale [39].
Le second paramètre dont il faut tenir compte est celui des données que l’on désire visualiser.
Une condition nécessaire d’utilisation des méthodes de précalcul est que la scène soit statique, c’est-
à-dire que la disposition spatiale de ses primitives ne change pas. Dans la plupart des scénarii de
visualisation, ce sera effectivement le cas pour la majorité de la scène (bâtiments, rochers, véhicule à
l’arrêt,...). Mais, si la scène est dynamique, seules les techniques en ligne sont utilisables. Par contre,
certaines scènes statiques se prêtent mieux à certaines méthodes que d’autres. Par exemple, les scènes
d’intérieur sont plus adaptées à un précalcul que les scènes d’extérieur, pour lesquelles l’espace na-
vigable 9 est typiquement beaucoup plus vaste. Notons également que les méthodes en ligne ne sont
pas toujours compétitives par rapport à l’algorithme <naı̈f> du <z-buffer> [12]. Ce paradoxe pro-
vient du fait qu’il est parfois plus coûteux de décider si l’on doit afficher un objet que de l’afficher
systématiquement. Il faut donc que le nombre de surfaces masquées -que l’on n’affiche pas- soit suffi-
sant, afin de compenser le coût supplémentaire introduit pour déterminer les occultations. Cette limite
est matérialisée par le point L dans les Figures 1.3 et 1.4 ( 10 ).
F IG . 1.4: Comparaison du temps de calcul des diff érentes techniques.
Cette limite est quasiment inexistante pour les méthodes utilisant un précalcul, car leur coût d’uti-
lisation lors de la phase interactive d’affichage est négligeable. La Figure 1.4 montre aussi que le
temps de calcul d’une telle méthode se rapproche du temps idéal obtenu en n’affichant que les sur-
faces visibles de la scène.
4 Objectifs de notre étude

Notre travail s’inscrit dans le cadre plus général d’un projet visant à explorer de manière interac-
tive des scènes complexes sur des machines d’entrée de gamme, telles que des ordinateurs personnels.
La contrainte la plus sévère est la faible puissance de calcul disponible pour effectuer la phase de vi-
sualisation interactive. Etant donné que les scènes sont statiques et que le temps de précalcul n’est pas
considéré comme limitatif, nous nous sommes tourné vers les méthodes d’<occlusion culling> avec
phase de précalcul, qui stockent l’information de visibilité et la réutilisent pour accélérer l’affichage
9 L’espace navigable est la zone de la scène accessible par la caméra lors de la navigation interactive.
10 Les Figures 1.3 et 1.4 font la supposition que le degré d’occultation (et donc l’efficacité des méthodes d’<occlusion
culling>) augmente avec le nombre de primitives de la scène, mais cette propriété n’est pas toujours vérifiée.
lors de la phase d’exploration interactive.
Cependant, ces méthodes soulèvent de nombreux problèmes théoriques, qui nécessitent, pour être
résolus, l’utilisation de notions mathématiques avancées. De plus, les problèmes rencontrés sont sou-
vent de nature combinatoire, et requièrent un traitement adéquat pour éviter une explosion du temps
de calcul. Les algorithmes qui en résultent ne sont pas triviaux et sont souvent complexes à mettre
en œuvre. En raison de ces difficultés, il n’existe pas aujourd’hui de solution générale satisfaisante,
permettant de traiter toutes les scènes de manière unifiée, et la recherche dans le domaine du précalcul
de visibilité est encore très active. Les travaux présentés dans ce document s’inscrivent précisément
dans ce cadre.
Notre principal objectif est de proposer de nouveaux algorithmes d’<occlusion culling> avec
précalcul, permettant d’accélérer l’affichage interactif de scènes tridimensionnelles. A l’instar des
méthodes de visibilité analytique, nous souhaitons calculer et stocker la visibilité de la manière la plus
précise possible, afin de nous rapprocher du cas idéal où seules les primitives visibles sont affichées.
Contrairement à ces méthodes, nous souhaitons encoder cette information de manière explicite, afin
de pouvoir l’utiliser ensuite de manière efficace pour accélérer l’affichage interactif de la scène. Nous
poursuivons donc un double objectif : d’une part, obtenir un algorithme de précalcul le plus exact
possible, d’autre part, proposer un mécanisme simple et rapide à utiliser pour exploiter l’information
précalculée lors de la phase de navigation interactive.
5 Plan de la thèse
Ce premier chapitre avait pour but de proposer un aperçu général du problème et d’introduire nos
contributions.
Le chapitre 2 contient un bref rappel des notions mathématiques nécessaires à la bonne compré-
hension de la suite du document. De manière plus précise, il contient de brèves introductions aux
coordonnées de Plücker et à la théorie des polyèdres.
Le chapitre 3 présente un état de l’art consacré aux algorithmes permettant de calculer et de sto-
cker l’information de visibilité d’une scène 3D.
Nous décrivons dans le chapitre 4 un algorithme permettant de déterminer de manière exacte si

deux polygones convexes sont mutuellement visibles, lorsque des écrans sont placés entre eux. Cet
algorithme est considérablement plus simple à mettre en œuvre que les algorithmes exacts existant
dans la littérature ; nous montrons qu’en termes de temps de calcul il est également beaucoup plus
efficace que ces derniers.
Dans le chapitre 5, nous introduisons une méthode originale pour encoder l’information de visi-
bilité, qui consiste à stocker l’ombre générée par chaque objet de la scène s’il était remplacé par une
source lumineuse. Nous présentons une analyse des avantages et des inconvénients de cette nouvelle
représentation.
Pour calculer la visibilité dans les scènes d’intérieur, les graphes cellules-portails sont souvent uti-
lisés. Dans le chapitre 6, nous reformulons le problème de la génération de ces graphes en termes de
5 Plan de la thèse 17
segmentation d’images, et adaptons l’algorithme classique de <watershed> pour générer ces graphes
de manière automatique.
Finalement, le chapitre 7 présente les conclusions et les perspectives de développement futur de

ce travail.
O u t i l s m a t h é m a t i q u e s
chapitre 2
Sommaire
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2 Introduction aux polyèdres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1 polyèdres et polytopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Faces d’un polyèdre et description combinatoire . . . . . . . . . . . . . . 21
2.3 Graphe d’incidence et 1-squelette . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Complexe de polyèdres et arrangement d’hyperplans . . . . . . . . . . . . 22
2.5 Graphe dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Espace dual et coordonnées de Plücker . . . . . . . . . . . . . . . . . . . . . . 24
3.1 Représentation d’une droite dans un espace dual . . . . . . . . . . . . . . 24
3.2 Coordonnées de Plücker . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1 Introduction
Ce chapitre regroupe les notions mathématiques nécessaires pour appréhender la suite du docu-
ment, et en particulier le chapitre 4.
Nous présentons dans la section 2 une introduction à la théorie des polyèdres ; nous renvoyons
néanmoins le lecteur à l’ouvrage de Boissonnat et al. [43] et à la thèse de Shaun Nirenstein [118] pour
de plus amples détails.
La section 3 contient une introduction à la notion d’espace dual, ainsi qu’aux coordonnées de
Plücker, qui furent introduites comme outils pour les calculs de visibilité par Seth Teller en 1992 [154].
Le lecteur trouvera plus de détails dans [20, 118, 131], et nous renvoyons à la thèse de Xavier Goaoc
pour une introduction rigoureuse du point de vue mathématique [70].
20 chapitre 2. Outils mathématiques
2 Introduction aux polyèdres

2.1 polyèdres et polytopes
Dans l’espace Rd à d dimensions, un polyèdre convexe P est constitué par l’ensemble des points
qui vérifient le système de n inéquations linéaires 1 :
d
∑ ai j (x j ) bi 8i 2 f1 ; :::; ng (2.1)
j =1
dans lesquelles ai j et bi sont des réels ; bi est aussi appelé <terme indépendant> de l’inéquation i,
Géométriquement, un hyperplan Hi : ∑dj=1 ai j (x j ) bi = 0 est associé à chacune des n inéquations
linéaires du système. Chacun de ces hyperplans Hi sépare l’espace en deux demi-espaces ouverts Hi +
et Hi - , situés de part et d’autre de Hi (cf. Figure 2.1).
F IG . 2.1: Un hyperplan H sépare l’espace en deux demi-espaces ouverts H + et H - .
Le polyèdre délimité par ces hyperplans est le lieu d’intersection des demi-espaces fermés négatifs
délimités par les hyperplans :
\n
P = Hi - (2.2)
i=1
Lorsqu’il est borné, un polyèdre est appelé polytope (cf. Figure 2.2). En d’autres termes, un po-
lytope est une région finie de Rd , délimitée par un nombre fini d’hyperplans.
(a) (b)
F IG . 2.2: Polytope 2D (a) H-représentation du polytope. (b) V-repr ésentation du polytope.
1 En programmation linéaire, les inéquations sont appelées contraintes, et le polyèdre P est appelé région de faisabilité.
2 Introduction aux polyèdres 21
Plutôt que de le définir à partir de ses facettes (H-représentation) (cf. Figure2.2(a)), un polyèdre
peut également être représenté à partir de ses sommets (V-représentation) (cf. Figure2.2(b)). Dans
ce cas, le polyèdre est défini comme étant le sous-ensemble de Rd formé par toutes les combinaisons
linéaires convexes de ses k sommets.
Par définition, une combinaison linéaire convexe ∑di=1 λiVi doit vérifier
d
∑ λi = 1 et 8i 2 f1 ; :::; kg; λi 0 (2.3)
i=1
Les deux représentations sont équivalentes, et le passage de l’une à l’autre est un problème clas-
sique de géométrie algorithmique connu sous le nom d’énumération de sommets (H-représentation
vers V-représentation). Le problème inverse est le problème d’énumération de facettes (V-représenta-
tion vers H-représentation), aussi connu sous le nom de calcul d’enveloppe convexe.
2.2 Faces d’un polyèdre et description combinatoire

Un polyèdre est composé de faces. Ces faces sont des ensembles convexes de Rd , dont la dimen-
sion est comprise entre 0 et d 1 ; une face de dimension j est appelée j-face.
Certaines faces possèdent des noms particuliers :
– les faces de dimension 0 (notées 0-faces) sont les sommets, notés Vi .
– les faces de dimension 1 (notées 1-faces) sont les arêtes, notées E [Vi ; V j ].
– les (d 1)-faces sont les facettes : elles correspondent aux hyperplans délimitant le polyèdre,
et sont notées Hi .
Par définition, la description combinatoire d’une face du polyèdre est la liste des hyperplans
auxquels la face appartient. La Figure 2.3 représente un cube dans R3 , ses facettes Hi sont les faces
du cube. La description combinatoire des sommets et des arêtes y est indiquée entre crochets.
(a) (b)
F IG . 2.3: (a) Sommets et côtés d’un polyèdre dans R3 . (b) Description combinatoire des sommets et des c ôtés.
Remarque : Comme on peut le voir sur la Figure 2.3(b), la description combinatoire de chaque arête
est composée de deux éléments, et est égale à l’intersection de la description combinatoire des deux
sommets qu’elle relie. D’une manière générale, la description combinatoire de chaque (k + 1)-face
est égale à l’intersection de la description combinatoire de deux k-faces distinctes (n’importe quelle
paire de k-faces qui sont des sous-faces de la face (k + 1)-face peuvent être utilisées).
2.3 Graphe d’incidence et 1-squelette

Le graphe d’incidence d’un polyèdre est un graphe dirigé, qui permet de représenter les rela-
tions d’incidence entre les faces du polyèdre. Le graphe d’incidence est aussi appelé le treillis du
polyèdre, et est également équivalent au diagramme de Hasse. Les nœuds de ce graphe sont les faces
du polyèdre. Si une k-face est contenue dans une (k + 1)-face, un arc dirigé existe entre la k-face et la
(k + 1)-face (cf. Figure 2.4).
F IG . 2.4: Graphe d’incidence du poly èdre de la Figure 2.3(b). Le 1-squelette est constitué par les éléments de
dimension 0 et 1 du graphe d’incidence (c’est- à-dire les sommets et les arêtes du polytope)
Le k-squelette d’un polyèdre est défini comme étant l’ensemble de ses faces de degré i k. Suivant
cette définition, le 1-squelette du polyèdre est le graphe composé par les arêtes et les sommets du
polyèdre (cf. Figure 2.4).
2.4 Complexe de polyèdres et arrangement d’hyperplans

Un complexe de polyèdres C fP0 ; ::; Pn g de dimension k est un ensemble de polyèdres Pi , chacun
d’entre eux étant connecté à ses voisins par une ou plusieurs faces.
Les complexes de polyèdres sont utilisés pour représenter des polyèdres non convexes (voire
même des polyèdres disjoints) en les décomposant en un ensemble de polyèdres convexes. Soit H un
ensemble de n hyperplans Hi de Rd . Cet ensemble H découpe l’espace Rd en polyèdres d’intérieurs
disjoints : l’ensemble de ces polyèdres forme un complexe cellulaire, que l’on appelle arrangement
de H (cf. Figure 2.5).
F IG . 2.5: Arrangement d’hyperplans. P i est un polyèdre, délimité par un sous-ensemble d’hyperplans de H .

L’ensemble des polyèdres forme un arrangement.
Les arrangements sont donc les complexes de polytopes qui sont obtenus lorsque l’espace est par-
titionné par un ensemble d’hyperplans. Chacune des faces du complexe est appelée cellule du com-
plexe. Comme dans le cas des polyèdres, les cellules des arrangements sont de dimension comprise
entre 0 et d 1, et sont des ensembles convexes de Rd .
2 Introduction aux polyèdres 23
Une face de dimension d k représente un ensemble de points qui appartiennent aux mêmes k
hyperplans.
2.5 Graphe dual

Soit un graphe planaire G. Par définition, une face de G est une région maximale du plan délimitée
par un ensemble d’arêtes de G, et qui n’en contient aucune. Le graphe dual G0 de G est un graphe dont
les nœuds correspondent aux faces de G, et dont les faces correspondent aux nœuds de G. Deux
nœuds de G0 sont connectés par un arc si les faces correspondantes de G ont une frontière commune
(cf. Figure 2.6). Un exemple classique est la triangulation de Delaunay, qui est obtenue en calculant
le graphe dual d’une partition de Voronoı̈ [45].
F IG . 2.6: Graphe dual. (a) Graphe G. (b) Un <point rouge> est associ é à chaque face de G. (c) Graphe G 0 ,
dual du graphe G, dont les sommets sont les <points rouges>.
3 Espace dual et coordonnées de Plücker

La visibilité s’étudie principalement en terme de droites, il est donc utile d’utiliser une descrip-
tion mathématique adéquate. La description des ensembles de droites n’est pas triviale dans R3 , car
il n’existe pas de paramétrisation naturelle des droites dans cet espace. De plus, les ensembles de
droites que nous allons étudier n’y forment pas des ensembles convexes, ce qui rend les opérations
géométriques difficiles. C’est pourquoi il est plus simple de considérer le problème dans un espace
dual, dans lequel les ensembles de droites se représentent de manière plus simple que dans l’espace
primal R3 dans lequel la scène est définie. A chaque droite d de l’espace primal est alors associé un
point D* de l’espace dual.
La dualité utilisée est celle de la géométrie algorithmique : travailler dans un espace dual consiste
à exprimer un problème géométrique dans un autre espace que l’espace primal dans lequel il est
défini. Pour ce faire, une dualité est définie, qui transforme les éléments géométriques de l’espace
primal (points, droites, plans,...) en éléments géométriques dans l’espace dual, et réciproquement (cf.
De Berg et al. page 169 [45]).
Remarque : Cette notion n’a donc rien à voir avec la dualité utilisée en algèbre linéaire, qui définit
l’espace dual d’un espace vectoriel V comme étant l’espace vectoriel V constitué de toutes les
formes linéairesa sur V [104]. Elle ne doit pas non plus être confondue avec la dualité utilisée en
programmation linéaire, qui est par exemple employée pour transformer un problème linéaire de
maximisation en son problème dual de minimisation afin de le résoudre de manière plus efficace (cf.
Cormen et al. page 779 [41]).
a Une forme linéaire est une application linéaire de l’espace vectoriel V dans le corps des scalaires K .
3.1 Représentation d’une droite dans un espace dual

Toute droite d de R3 possède quatre degrés de liberté. Pour s’en convaincre, associons à d les
coordonnées (a1 ; b1 ) et (a2 ; b2 ) de ses deux points d’intersection avec deux plans parallèles (cf.
Figure 2.7(a)). Le choix des plans est quelconque, pour autant qu’ils soient invariants et servent
pour toutes les droites. Dans ce cas, chaque coordonnée correspond à un degré de liberté. Cette pa-
ramétrisation pourrait être utilisée pour définir un espace dual, dans lequel la droite d serait représentée
par le point D (a1 ; b1 ; a2 ; b2 ). Malheureusement, cette paramétrisation possède des singularités, car
certaines droites ne peuvent être représentées : ce sont les droites parallèles aux deux plans. Considérons
une autre paramétrisation, et associons à la droite d les coordonnées (θ1 ; φ1 ; θ2 ; φ2 ), avec (θ1 ; φ1 ) et
(θ2 ; φ2 ) les coordonnées sphériques des points d’intersection de la droite avec une sphère entourant
la scène2 (cf. Figure 2.7(b)). Il existe de nouveau des singularités (les droites qui ne possèdent pas
d’intersection avec la sphère). D’une manière plus générale, il existera des singularités quelle que
soit la paramétrisation 4D choisie, car il n’est pas possible d’obtenir une paramétrisation continue des
droites à quatre dimensions [54].
Une solution consiste à abandonner la paramétrisation 4D et à utiliser une paramétrisation de
dimension supérieure. Une paramétrisation 5D classique est la paramétrisation (x; y; z; θ; φ) dans la-
quelle (x; y; z) sont les coordonnées d’un point de la droite et (θ; φ) sont des coordonnées sphériques
représentant sa direction. Le degré de liberté supplémentaire correspond à la liberté que l’on a de
choisir librement le point (x; y; z) sur la droite. Une autre paramétrisation est la paramétrisation 6D
2 Cette condition permet de s’assurer que toutes les droites traversant la scène possédent une intersection avec la sphère.
3 Espace dual et coordonnées de Plücker 25
(a) (b)
F IG . 2.7: Exemples de paramétrisation 4D d’une droite. (a) Intersections avec deux plans parall èles. (b) Inter-
sections avec une sphère.
(x1 ; y1 ; z1 ; x2 ; y2 ; z2 ),
dans laquelle (x1 ; y1 ; z1 ) et (x2 ; y2 ; z2 ) sont les coordonnées 3D de deux points de
la droite. Dans ce cas, les deux degrés de liberté supplémentaires correspondent au choix des deux
points pour définir la droite. La paramétrisation à l’aide des coordonnées de Plücker, qui fait l’objet
de la section suivante, est également une paramétrisation 6D très utilisée en visibilité3 .
3.2 Coordonnées de Plücker

3.2.1 Introduction
Comme nous le verrons dans ce chapitre, l’espace de Plücker est un espace dual 6D, dans lequel
chaque droite d de l’espace primal R3 peut être représentée de deux manières différentes :
– soit sous la forme d’un hyperplan Hd .
– soit sous la forme d’un point D .
Considérons deux droites a et b, et supposons que nous ayons transformé la droite a en point A de
l’espace de Plücker et la droite b en l’hyperplan Hb dans l’espace de Plücker. Comme nous le verrons
dans le paragraphe 3.2.4.2 le signe de l’expression Hb (A ), obtenue en injectant les coordonnées du
point A dans l’équation de l’hyperplan Hb , permet de connaı̂tre les positions relatives des droites a et
b (droites sécantes, parallèles ou gauches) ainsi que sur leur orientation respectives. Dès lors, de nom-
breux problèmes de visibilité peuvent être résolus en calculant les solutions de systèmes d’inéquations,
chacune de ces inéquations correspondant géométriquement à l’un des hyperplans. Afin de donner au
lecteur un aperçu des possibilités offertes par l’utilisation de l’espace des droites, nous avons regroupé
ci-dessous quelques problèmes survenant dans l’étude de la visibilité, et qui peuvent être résolus plus
facilement dans l’espace dual de Plücker que dans l’espace primal. Nous introduisons les coordonnées
de Plücker proprement dites dans le paragraphe 3.2.4.2.
3.2.1.1 Exemple 1 : droites poignardant un segment de R2 Dans ce premier exemple, nous

décrivons comment représenter dans l’ensemble dual l’ensemble des droites qui poignardent un seg-
ment 2D 4 . Ce problème se pose fréquemment en visibilité, lorsque l’on représente les ensembles de
3 Dans ce cas, il existe également deux degrés de liberté supplémentaires : le premier correspond à la projectivité de
l’espace de Plücker, et le second au fait que seul un sous-espace de l’espace de Plücker, appelé quadrique de Plücker,
correspond à l’ensemble des droites réelles dans R3 .
4 Cette explication est très largement inspirée de [23].
droites qui sont bloquées par un écran. Lorsque’une droite possède une intersection avec une primitive
géométrique, on dit que la droite poignarde cette primitive, et on l’appelle droite poignardante5 .
(a) Espace primal (b) Espace dual des droites(après projection)
F IG . 2.8: Représentation d’un segment dans l’espace dual (image d’apr ès [23]).
Soit un segment de droite P0 P1 défini dans R2 . Pour passer de l’espace primal R2 à l’espace dual
des coordonnées de Plücker correspondant, un point est transformé en une droite et une droite en
un point (cf. paragraphe 3.2.3). Dès lors, P0 P1 est représenté dans l’espace dual comme un double
coin, délimité par les deux hyperplans HP0 et HP1 (cf. Figure 2.8). Ces deux hyperplans possèdent un
point d’intersection S , correspondant dans l’espace primal à la droite s, support du segment P0 P1 .
L’ensemble des droites qui possèdent une intersection avec le segment P0 P1 est l’ensemble des points
de l’espace dual représenté en gris sur la Figure 2.8 et situés à l’intersection :
– du demi-espace négatif délimité par HP0 et du demi-espace positif délimité par HP1 .
– du demi-espace positif délimité par HP0 et du demi-espace négatif délimité par HP1 .
La droite orientée l0 laisse le points P0 et P1 à sa droite : son point dual L0 est donc situé dans les
deux demi-espaces positifs délimités par HP0 et par HP1 . Au contraire, la droite l4 laisse les points P0
et P1 sur sa gauche et son point dual L4 est situé dans les deux demi-espaces négatifs délimités par
HP0 et par HP1 . La droite l1 passe par le point P0 , et son point dual L1 est donc situé sur l’hyperplan
HP0 . Finalement, les droites l2 et l3 ont un point dual dans deux <coins> opposés car leur orientation
est opposée.
En conclusion, l’espace dual permet de représenter l’ensemble des droites qui poignardent un segment
sous la forme d’un polygone en forme de double coin. Il est ensuite aisé de déterminer si une droite
transperce ou non le segment en testant dans l’espace dual sa position par rapport au double coin.
3.2.1.2 Exemple 2 : intersection d’une droite et d’un polygone dans R3 Nous présentons un
exemple similaire à l’exemple 1, mais cette fois dans R3 . Soit un polygone convexe défini par ses
arêtes ei , 0 i < n (cf. Figure 2.9). Nous nous posons le problème de savoir si une droite l donnée
poignarde ce polygone. Ce problème est très commun en synthèse d’images, puisqu’il est au cœur de
tous les algorithmes de <lancer de rayons> 6 . La condition nécessaire et suffisante pour que la droite
5Les droites poignardantes sont les <Stabbing Lines> en anglais.
6Les algorithmes de <lancer de rayons> (<ray tracing> en anglais) construisent une image de la scène en calculant les
intersections de rayons de vue, issus du centre optique de la caméra, avec la géométrie de la scène ; une image complète de
l poignarde le polygone est qu’elle possède une orientation identique par rapport à chacun des côtés
du polygone.
F IG . 2.9: Détermination de l’existence d’une intersection entre la droite l et le polygone (e 0 ,e1 ,e2 ).
Cette condition s’exprime facilement dans l’espace dual [20]. Pour ce faire, l’ensemble des droites
supports des arêtes ei est transformé en autant d’hyperplans Hei dans l’espace dual avec l’équation
(2.11) et l est transformé en un point L avec l’équation (2.8).
D’après l’équation (2.14), on déduit que la droite l possédera une intersection avec le polygone si
et seulement si Hei (L ) 0 pour 0 i n (ou si Hei (L ) 0 pour 0 i < n dans le cas où la droite
est orientée dans le sens inverse de la normale du polygone). D’une manière générale, l’ensemble
des droites poignardant le polygone correspond à l’ensemble des points X de P5o appartenant à la
quadrique de Plücker et vérifiant simultanément les équations Hei (X ) 0 pour 0 i n (nous ne
considérons ici que les droites orientées dans le sens de la normale du polygone).
3.2.1.3 Exemple 3 : droites poignardant k polygones convexes dans R3 Considérons mainte-

nant k polygones convexes de nk côtés (nous supposons que les côtés de ces polygones sont orientés
de manière consistante). Nous souhaitons maintenant déterminer s’il existe au moins une droite poi-
gnardant simultanément les k polygones. Ce problème se pose notamment dans les calculs de visibilité
à travers une séquence de portails (cf. page 62).
La réponse à cette question est simple une fois le problème exprimé dans l’espace dual de Plücker.
Comme pour l’exemple précédent, transformons l’ensemble des (knk ) côtés des polygones en hyper-
plans dans l’espace de Plücker (cf. Figure 2.10).
Ces plans définissent un système d’inéquations linéaires : il existera une droite poignardant l’en-
semble des polygones si et seulement si ce système d’inéquations admet au moins une solution, et que
cette solution appartient à la quadrique de Plücker. La détermination de l’existence d’au moins une
solution d’un système d’inéquations linéaires est classique en programmation linéaire, et pourra être
résolu à l’aide d’une méthode standard de programmation linéaire [154].
3.2.2 Définition mathématique des coordonnées de Plücker

Les coordonnées de Grasmann permettent de paramétrer le sous-espace vectoriel à k dimensions

d’un
espace vectoriel à n dimensions, comme étant un point dans un espace projectif de dimension
n+1
1 [120].
k+1
Les coordonnées de Plücker sont un cas particulier de coordonnées de Grassmann, utilisées pour
paramétrer des droites, c’est-à-dire des espaces vectoriels de dimension 1 de l’espace R3 (k = 1 et
la scène peut être obtenue en utilisant un rayon de vue pour chaque pixel de l’image, et en associant à ce pixel la couleur de
la première primitive rencontrée.
F IG . 2.10: Ensemble de droites poignardant un ensemble de polygones : les c ôtés des polygones sont trans-
formés en hyperplans dans l’espace dual, les intersections de ces hyperplans avec la quadrique de Pl ücker sont
suggérées (à droite). L’ensemble des hyperplans d élimite une hypersurface sur la quadrique de Pl ücker, qui
correspond à l’ensemble des droites réelles poignardant l’ensemble des polygones.
n = 3). Cela signifie que la dimension de l’espace projectif associé est de dimension 5. Etant donné les
difficultés pour représenter un espace de ce type, nous commençons par introduire les coordonnées de
Plücker décrivant les droites du plan, pour donner au lecteur une première intuition avant de présenter
les coordonnées de Plücker pour les droites de l’espace.
3.2.3 Coordonnées de Plücker dans R2 [23]

Nous sommes donc dans le cas d’une droite dans R2 (k = 1 et n = 2), et l’espace des droites est
un espace projectif 7 à 2 dimensions P2 .
Tout espace projectif à d dimensions peut être vu comme un espace à d + 1 dimensions dont on
ne considère que les éléments passant par l’origine [118] 8 . L’espace projectif 2D peut donc être vu
comme un espace 3D, dont tous les éléments contiennent l’origine. Dès lors, un hyperplan projectif
2D peut être vu comme un plan contenant l’origine dans un espace 3D. Par souci de facilité, nous
adoptons la représentation introduite par Bittner et al. [23] et représentons les hyperplans par leur
trace sur un plan de projection (autrement dit nous représentons les hyperplans projectifs comme des
droites dans un plan R2 ). Nos représentations de l’espace dual ne sont que des schémas de principe,
qui peuvent être vus comme étant des projections des éléments géométriques sur un hyperplan de
projection choisi de telle manière qu’aucune singularité n’arrive lors de la projection.
Soit la droite orientée a de R2 , passant d’abord par le point P( px ; py ) et ensuite par le point
Q(qx ; qy ). Dans l’espace de Plücker, on lui associe le point A dont les coordonnées (π0 a ; π1 a ; π2 a )
sont définies par :
8
< π0 a = py qy
π1 a = qx px
: π2 a = px qy qx py
(2.4)
7 Pour une introduction aux espaces projectifs, nous renvoyons à la thèse de Nirenstein [118] et à l’ouvrage de
Stolfi [149].
8 De manière plus précise, les éléments <passent> par l’origine au sens géométrique du terme, mais ils ne contiennent
pas l’origine qui est un point qui n’appartient pas à l’espace projectif.
Les coordonnées πi a , appelées les coordonnées de Plücker de la droite, sont les mineurs πi de la
matrice :

px py 1
(2.5)
qx qy 1
En raison de la projectivité, le point A est défini à une constante multiplicative près :
A = (π0 a ; π1 a ; π2 a )
= (sπ00 a ; sπ01 a ; sπ02 a ) (2.6)
= sA0 et s 2 R+
En pratique, cela se traduit par la liberté que l’on a de choisir n’importe quelle paire de points P et
Q sur la droite pour calculer ses coordonnées de Plücker, chaque choix fournissant des coordonnées
égales à un facteur multiplicatif près.
Remarque : L’espace de Plücker est un espace projectif orienté, ce qui signifie que la constante
multiplicative s doit être strictement positive. La droite de vecteur directeur PQ et celle de vecteur
directeur QP correspondent donc à deux points différents dans l’espace de Plücker [149].
3.2.3.1 Dualité point-hyperplan Nous venons de voir qu’une droite de R2 est transformée en
un point de l’espace dual par l’intermédiaire des coordonnées de Plücker. Un point P( px ; py ) sera
transformé dans l’espace dual en un hyperplan Hp d’équation px x + py y + z = 0. Comme on peut le
constater, cette équation peut être vue comme étant l’équation d’un plan contenant l’origine dans un
espace à 3 dimensions.
3.2.3.2 Position relative d’une droite par rapport à un point Considérons un point P et une
droite a. La droite a est transformée dans l’espace dual en un point A , et le point P est transformé en
un hyperplan Hp .
Le signe de l’expression Hp (A ), obtenue en injectant les coordonnées de A dans l’équation de
l’hyperplan Hp nous donne l’orientation relative de la droite a par rapport au point P dans R2 (cf.
Figure 2.11).
Espace primal R2
Espace dual de Plücker (2D)

H p (A ) > 0 H p (A ) = 0 H p (A ) < 0
F IG . 2.11: Position relative de la droite a et du point P en utilisant l’espace de Pl ücker (H p représente la trace
des hyperplans dans un plan de projection).
8
< Si H p (A ) > 0; la droite orientée a laisse le point P à sa droite
Si H p (A ) = 0; la droite orientée a passe par le point P
: Si H p (A ) < 0; la droite orientée a laisse le point P à sa gauche
(2.7)
3.2.4 Coordonnées de Plücker dans R3

Soit la droite orientée a de R3 , passant d’abord par le point P( px ; py ; pz ) et ensuite par le point
Q(qx ; qy ; qz ). Dans l’espace de Plücker, on lui associe le point A de coordonnées
(π0 a ; π1 a ; π2 a ; π3 a ; π4 a ; π5 a ) avec :
8
>
>
>
π0 a = qx px
>
>
> π1 a = qy py
< π2 a = qz pz
>
>
> π3 a = qz py qy pz
(2.8)
>
>
> π4 a = qx pz qz px
: π5 a = qy px qx py
Tout comme en 2D, les coordonnées πi a sont appelées les coordonnées de Plücker de la droite, et
sont les mineurs πi de la matrice :

px py pz 1
(2.9)
qx qy qz 1
En raison de la projectivité, le point A est défini à une constante multiplicative près :
A = sA0 et s 2 R+ (2.10)
L’espace de Plücker associé aux droites de l’espace 3D est un espace projectif orienté 5D. Il peut
donc être vu comme un espace 6D, dont tous les éléments passent par l’origine, et il constitue bien
une paramétrisation 6D des droites. Etant donné les difficultés inhérentes à la visualisation des espaces
multi-dimensionnels, nous effectuerons souvent des analogies entre ces espaces et les espaces 2D ou
3D. Nous mettons le lecteur en garde par rapport à ces analogies et à ces illustrations, dont le but est
de fournir un support visuel, et qui n’ont pas la prétention d’être correctes à <tout point de vue>. Dans
la suite du document, nous indiquerons explicitement les illustrations qui sont sujettes à caution.
3.2.4.1 Dualité droite-hyperplan Nous avons vu que la droite a était associée au point A dans
l’espace de Plücker. Outre ce point, il est également possible d’associer la droite a à un hyperplan Ha
passant par l’origine dans l’espace de Plücker. La droite a peut de la sorte être transformée soit en un
point A , soit en un hyperplan Ha . Les coefficients ϖi a de cet hyperplan sont appelés les coordonnées
de Plücker duales de la droite a.
Ha (X ) = ϖ0 a x0 + ϖ1 a x1 + ϖ2 a x2 + ϖ3 a x3 + ϖ4 a x4 + ϖ5 a x5 = 0 (2.11)
Les coordonnées de Plücker duales ϖi a sont obtenues par permutation des coordonnées de Plücker
πi a
8
>
>
>
ϖ 0 a = π3 a
>
>
> ϖ 1 a = π4 a
< ϖ 2 a = π5 a
>
>
> ϖ 3 a = π0 a
(2.12)
>
>
> ϖ 4 a = π1 a
: ϖ 5 a = π2 a
En remplaçant dans l’équation 2.11, nous obtenons
Ha (X ) = π3 a x0 + π4 a x1 + π5 a x2 + π0 a x3 + π1 a x4 + π2 a x5 = 0 (2.13)
Le vecteur normal de cet hyperplan est Na (π3 a ; π4 a ; π5 a ; π0 a ; π1 a ; π2 a ).
3.2.4.2 Position relative de deux droites Considérons deux droites a et b, que l’on transforme
respectivement en un hyperplan Ha et en un point B . Le signe de l’expression Ha (B ), obtenue en
injectant les coordonnées de B dans l’équation de l’hyperplan Ha nous donne l’orientation relative9
des droites a et b dans R3 (cf. Figure 2.12).
Espace primal R3
Espace dual de Plücker (5D)

Ha (B ) > 0 Ha (B ) = 0 Ha (B ) < 0
F IG . 2.12: Position relative des droites a et b en utilisant l’espace de Pl ücker 3D.
L’orientation est donnée par la direction d’une des droites par rapport à un observateur regardant
dans la direction de la seconde, et en utilisant la <règle de la main droite> 10 .
8
< Si Ha (B ) > 0; les deux droites sont gauches (sens horlogique)
Si Ha (B ) = 0; les deux droites sont concourantes
: Si Ha (B ) < 0; les deux droites sont gauches (sens anti-horlogique)
(2.14)
9 Cette interprétation est possible car nous travaillons dans un espace projectif orienté, et que a et b sont elles-mêmes
des droites orientées [43].

10 Aussi appelée règle d’Ampère.
3.2.4.3 Quadrique de Plücker Si toute droite de R3 possède un point dual dans l’espace de
Plücker, celui-ci au contraire contient essentiellement des points qui correspondraient dans l’espace
primal à des droites à coefficients imaginaires, et qui n’existent donc pas dans R3 . Les seuls points qui
possèdent une correspondance sont ceux appartenant à la quadrique de Plücker, définie comme étant
le lieu des points X vérifiant l’équation :
Hx (X ) = 0
, π0 π3 + π1 π4 + π2 π5 = 0
(2.15)
Par définition, toute droite réelle r appartient à la quadrique de Plücker car elle vérifie Hr (R ) = 0.
Cette quadrique est une surface 4D, dont l’analogue tridimensionnel pourrait être un hyperboloı̈de à
une nappe (cf. Figure 2.13).
F IG . 2.13: La quadrique de Pl ücker est un sous-espace affin 4D plong é dans l’espace projectif 5D de Pl ücker.
L’espace dual correspondant aux droites réelles est donc la sous-partie de l’espace de Plücker
constituée par la quadrique de Plücker.
Remarque : Les hyperplans duaux de droites réelles sont en fait tangents à la quadrique de Plücker.
En effet, il est facile de vérifier que le vecteur normal Np de l’hyperplan Hp est également normal à
la quadrique de Plücker au point P .
chapitre
Etat de l’art
3
Sommaire
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2 Visibilité analytique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.1 Graphe d’aspect et partition <VSP> . . . . . . . . . . . . . . . . . . . . . 35
2.2 La structure de données <Asp> . . . . . . . . . . . . . . . . . . . . . . . 41
2.3 Arrangement d’hyperplans dans l’espace de Plücker . . . . . . . . . . . . 42
2.4 Méthodes de visibilité globales . . . . . . . . . . . . . . . . . . . . . . . . 42
2.5 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3 Encodage de la visibilité sous la forme de <PVS> . . . . . . . . . . . . . . . . . 46
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2 Algorithmes de visibilité depuis une région . . . . . . . . . . . . . . . . . 48
3.3 Partition de l’espace navigable en cellules . . . . . . . . . . . . . . . . . . 55
3.4 Stockage de <PVS> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.5 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4 Encodage de la visibilité sous la forme de graphes cellules-portails . . . . . . . 60
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.2 Génération automatique de graphes cellules-portails . . . . . . . . . . . . 61
4.3 Détermination des objets masqués à partir d’un graphe cellules-portails . . 62
4.4 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
1 Introduction
Le domaine de la visibilité est très vaste et couvre beaucoup de disciplines. En synthèse d’images,
il est au centre de différentes problématiques fondamentales, telles que le calcul de vues, le calcul
d’ombres ou le calcul d’illumination globale. Il intervient aussi en robotique avec les problèmes de
localisation, de suivi de cibles et de calcul de plus courts chemins ; on le retrouve également en vision
par ordinateur, avec l’inspection et la reconnaissance d’objets, ainsi qu’en astronomie avec l’étude
des éclipses. Il intervient même dans les traitements géométriques, sous la forme de simplification de
maillage guidée par la visibilité. Le lecteur intéressé en trouvera un panorama inter-disciplinaire dans
la thèse de Frédo Durand [54].
34 chapitre 3. Etat de l’art
Dans ce travail, nous nous intéressons aux méthodes de visibilité utilisées en synthèse d’images,
et plus précisément pour le calcul de vues. La Figure 3.1 présente une classification des méthodes
existantes, en fonction de la manière dont ces méthodes stockent (ou ne stockent pas) l’information
de visibilité. La présentation de toutes ces techniques sortirait du cadre de notre étude, consacrée au
précalcul et au stockage de l’information de visibilité dans des scènes 3D. Nous avons donc choisi
délibérément de ne pas présenter les techniques d’élimination de faces cachées en ligne (cf. page14)
puisqu’elles ne stockent pas la visibilité et éliminent les objets masqués au cours de la navigation
interactive. Nous renvoyons le lecteur intéressé par l’<occlusion culling> en ligne aux récents états
de l’art consacrés à ce sujet [83, 35, 124, 18] et à l’ouvrage de Foley et al. [63] pour une présentation
des techniques de <hidden surface removal>(notées <HSR> dans la figure).
F IG . 3.1: Classification des méthodes de visibilité utilisées en synthèse d’images pour le calcul de vues. Les
méthodes étudiées dans cet état de l’art sont entourées d’un cercle grisé.
Nous avons scindé l’état de l’art en trois parties. La première est consacrée aux approches de visi-
bilité analytique, qui encodent l’information de visibilité de manière complète et exacte (graphe d’as-
pect, approches de visibilité globale, <Asp> et arrangements d’hyperplans de Pellegrini) (section2).
La deuxième et la troisième partie présentent les méthodes utilisées dans le domaine de l’<occlusion
culling> avec précalcul, qui encodent la visibilité de manière approchée : les méthodes de calcul de
PVS sont présentées dans la section 3 et les méthodes basées sur le modèle des graphes cellules-
portails (notées <CPG> 1 dans la figure) sont présentées dans la section 4.
1 <CPG> pour <Cell-and-Portal Graph> en anglais.
2 Visibilité analytique 35
2 Visibilité analytique
Nous avons regroupé dans ce paragraphe les méthodes qui encodent l’information de visibilité
de manière complète et exacte. Nous allons voir qu’elles sont principalement d’intérêt théorique, car
elles sont encore trop complexes à mettre en œuvre pour être utilisées pour l’<occlusion culling>.
2.1 Graphe d’aspect et partition <VSP>

2.1.1 Définition
Soit C l’œil d’une caméra observant une scène polygonale, composée exclusivement de polygones
opaques, chacun d’entre eux étant délimité par un ensemble d’arêtes ai . Par définition, un aspect de
la scène représente une de ses vues, c’est-à-dire l’image obtenue en projetant la scène depuis un
point de vue particulier. Deux aspects sont considérés comme identiques s’ils représentent des vues
qualitativement équivalentes 2 . Un graphe d’aspect est un graphe planaire, qui encode toutes les vues
possibles d’une scène. Il vérifie les propriétés suivantes :
– chaque aspect est unique et est encodé dans un des nœuds du graphe.
– chaque nœud est connecté à ses voisins par un arc. Deux nœuds sont voisins si leurs aspects ne
diffèrent que par un et un seul changement topologique 3
A titre d’exemple, la Figure 3.2 représente le graphe d’aspect d’un cube, lorsque la projection
perspective est utilisée.
F IG . 3.2: Le graphe d’aspect d’un cube en projection perspective (image d’apr ès [58]).
Considérons l’espace navigable d’une scène, et découpons-le en régions d’aspect constant : pour
un utilisateur restant à l’intérieur d’une région, l’aspect qu’il perçoit reste qualitativement identique.
Plantinga a appelé cette partition de l’espace navigable en régions d’aspect constant la <partition
VSP>, pour <View Space Partition> [128].
2 Par définition, deux vues sont qualitativement équivalentes lorsque les sommets et les arêtes sont disposés de manière
similaires dans les deux vues.
3 Un changement topologique entre deux vues désigne la modification entre les vues de la disposition respective des
arêtes et des sommets. Deux vues sont qualitativement équivalentes si aucun changement topologique n’est nécessaire pour
passer de l’une à l’autre.
Par définition, le graphe d’aspect est le graphe dual 4 de la <partition VSP>. A titre illustratif, la
Figure 3.3 présente la <partition VSP> d’une scène simple et le graphe d’aspect correspondant.
(a) (b)
F IG . 3.3: (a) <Partition VSP> (partition de l’espace navigable en cellules d’aspect constant).(b) Graphe d’as-
pect. Ce graphe est le dual de (a) : on associe un nœud du graphe d’aspect à chaque cellule de la partition et
les frontières entre les différentes cellules correspondent aux arcs du graphe.
2.1.2 Frontières entre régions d’aspect constant

Considérons une vue en fil de fer d’une scène (c-à-d un aspect), calculée sur une sphère entourant
l’œil C de la caméra, tout en éliminant les arêtes masquées. Sur la surface de cette sphère, la projection
des objets est délimitée par la projection de ses arêtes. Les points d’intersection de ces projections sont
les sommets. On distingue les sommets réels, qui correspondent à la projection du sommet d’une des
primitives de la scène, et les sommets apparents, qui correspondent à la projection d’arêtes gauches
en 3D qui sont superposées dans l’image après projection. Lorsque C se déplace, la sphère se déplace
avec elle : les projections des primitives se déplacent sur la surface de vue. La plupart du temps, la vue
change seulement de manière quantitative : les côtés changent de taille, et les sommets se déplacent les
uns par rapport aux autres. La vue reste constante tant que sa structure combinatoire ne change pas.
Mais à un certain moment, la vue changera de manière qualitative : un sommet (réel ou apparent) S
de l’image traverse une arête projetée ai ; on dit qu’un événement de visibilité a lieu (cf. Figure 3.4).
Lorsqu’une caméra se déplace dans une scène, les changements topologiques de l’image qu’elle
observe coı̈ncident avec les événements de visibilité, et surviennent lorsque le point de vue change de
région d’aspect constant dans la partition <VSP>. Les frontières de ces régions sont des surfaces, ap-
pelées les surfaces critiques 5 de la scène. Dans certains cas, le franchissement d’une surface critique
coı̈ncide avec l’apparition ou la disparition d’une primitive au sein de la vue. Dans d’autres cas, il
s’agit simplement d’un changement topologique au sein de la vue, mais les mêmes primitives sont vi-
sibles de part et d’autre de la surface critique. Les surfaces critiques sont donc les lieux de changement
de visibilité. Mais si tous les changements de visibilité correspondent à la traversée d’une surface cri-
tique, l’inverse n’est pas vrai, puisque la traversée de la plupart des surfaces critiques n’entraı̂ne qu’un
changement topologique dans la vue.
4 La définition du graphe dual d’une partition est donnée page 23.
5 Les surfaces critiques sont les <critical swaths> en anglais.
(a) (b)
F IG . 3.4: Franchissement d’un événement de visibilité (d’après [54]). Le point de vue se déplace depuis le
point 1 jusqu’au point 3. Lorsqu’il traverse la surface critique, un événement de visibilité a lieu dans l’image
observée. (a) Sommet réel. (b) Sommet apparent.
Dans le cas particulier des scènes polygonales, les surfaces critiques s’appuient sur les arêtes des
polygones de la scène. Ce sont des quadriques réglées 6 , qui peuvent éventuellement dégénérer en un
plan. Les surfaces critiques ne sont pas des surfaces infinies, mais plutôt des morceaux de surfaces.
Elles sont délimitées, d’une part lorsque la surface rencontre une primitive de la scène7 , d’autre part
lorsqu’elle rencontre une autre surface critique. L’intersection de deux surfaces critiques est une droite,
qui joue un rôle très important en visibilité, et qui est appelée droite poignardante extrême 8 [154].
Remarque : Puisque le graphe d’aspect est le dual de la partition, cela signifie que les arcs du graphe
d’aspect représentent les surfaces critiques [69].
Analogie avec une source lumineuse Les problèmes de visibilité s’expliquent de manière simple
en utilisant une analogie avec une source lumineuse. Soit S un polygone de la scène, dont on désire
connaı̂tre le graphe d’aspect : l’analogie consiste à remplacer S par une lampe éclairant le reste de la
scène [47]. C’est pour cette raison que les objets qui en masquent d’autres sont appelés écrans dans
la littérature sur la visibilité. Comme on peut le voir sur la Figure3.5, la source lumineuse génère des
ombres et des pénombres en éclairant les écrans. Les surfaces séparant les ombres, les pénombres et
la pleine lumière sont précisément les surfaces critiques. Les intersections des surfaces sont les droites
poignardantes extrêmes.
2.1.3 Description des surfaces critiques

Considérons une caméra virtuelle balayant une scène, et intéressons-nous à un de ses rayons de
vue en particulier 9 . Ce rayon est bloqué par le premier objet visible Oi . Lors de son déplacement, ce
rayon va finir par atteindre le bord de Oi , pour ensuite lui devenir tangentiel. Si la caméra continue
son déplacement, le rayon va se détacher de l’objet pour atteindre un nouvel objet, qui sera le nouvel
6 Une quadrique est une surface algébrique de degré 2. Par définition, cette surface est réglée si et seulement si par tout
point il passe au moins une droite entièrement contenue dans la surface.

7 Les surfaces critiques sont en quelque sorte <découpées> par les primitives de la scène.
8 Les droites poignardantes extrêmes sont les <extremal stabbing lines> en anglais.
9 Un <rayon de vue> d’une caméra est une demi-droite, dont l’extrémité est le centre optique de la caméra.
F IG . 3.5: Analogie avec une source lumineuse. (a) En éclairant un écran, la source lumineuse S crée des ombres
et des pénombres. (b) Les surfaces critiques délimitent les zones d’ombre, de pénombre et de pleine lumière. (c)
Les droites poignardantes extrêmes sont situées à l’intersection des surfaces critiques.
objet visible. Cette observation nous donne une première indication sur les lieux de modification de
la visibilité : les changements de visibilité ont lieu lorsqu’un rayon devient tangent à un objet. D’une
manière générale, l’étude analytique de la visibilité consiste à étudier ces lieux de tangence.
2.1.3.1 Cas continu Considérons d’abord un ensemble de droites tangentes à un objet continu
lisse, c’est-à-dire un objet dont la surface est une surface algébrique, de degré borné, et qui ne possède
pas de singularités. Lorsque l’on impose à une droite de rester tangente à un (ou plusieurs) objets,
ces contraintes diminuent d’autant ses degrés de liberté. L’ensemble des droites tangentes à cet objet
forme une variété à trois dimensions, car chacune des droites de cet ensemble peut être déplacée selon
trois degrés de liberté tout en restant tangente à l’objet (cf. Durand [54] page 35). Dans l’espace dual,
l’ensemble des droites tangentes à un objet est transformé en un ensemble de points, qui forment une
hypersurface à 3 dimensions, appelée <l’hypersurface des tangentes> [70].
Soit L le point dans l’espace dual correspondant à la droite l dans l’espace primal euclidien. Si
L appartient à cette hypersurface, cela signifie que l est tangente à l’objet. Si L est à l’<intérieur> de

l’hypersurface, la droite possède une intersection avec l’objet. On dit que la droite poignarde l’objet,
et on l’appelle droite poignardante.
Considérons maintenant deux objets, et leur hypersurface des tangentes respective. Si L , point
dual d’une droite l, est simultanément à l’intérieur de ces deux hypersurfaces de tangentes, cela si-
gnifie que la droite l poignarde les deux objets. Dans l’espace dual, le lieu d’intersection de ces deux
hypersurfaces de tangence est une hyperpsurface 2D. On peut continuer de même et considérer les
ensembles des droites tangentes à 3 et à 4 objets, qui décrivent des hypersurfaces 1D et 0D.
Nous avons déjà rencontré les ensembles de droites tangentes à trois objets : ce sont des surfaces
2D dans l’espace primal, appelées surfaces critiques. En termes de droites, il s’agit de variété 1D.
Les ensembles de droites tangentes à quatre objets des droites isolées, appelées droites poignardantes
extrêmes. En termes de droites, il s’agit donc de variété 0D : dans l’espace dual, ces droites corres-
pondent à un et un seul point, situé à l’intersection des quatre hypersurfaces de tangentes.
Pour résumer, on peut dire que l’ensemble des droites tangentes simultanément à n objets lisses
forment une variété à 4 n dimensions, pour n 4. Les droites tangentes à trois objets sont des
surfaces réglées, appelées surfaces critiques, et les droites tangentes à quatre objets sont des droites
ponctuelles appelées droites poignardantes extrêmes10 .
2.1.3.2 Cas linéaire par morceaux Dans ce document, nous ne nous intéressons pas aux objets
lisses mais à leur représentations sous formes de maillages. Dans ce cas particulier, la surface de
l’objet, décrite à l’aide de polygones, est linéaire par morceaux. Les bords des objets sont des segments
de droites (les arêtes), et les objets ne sont plus lisses puisque chaque sommet du maillage est une
singularité locale.
Les surfaces critiques s’appuient sur les arêtes des polygones de la scène. Ce sont des quadriques
réglées, qui peuvent éventuellement dégénérer en un plan, et dont les intersections sont les droites
poignardantes extrêmes.
Nous considérons d’abord que les objets sont en configuration générique 11 , et enlevons ensuite
cette contrainte.
<En position générique> signifie qu’il n’existe :
– pas d’arêtes parallèles
– aucune combinaison de quatre arêtes appartenant à une même quadrique réglée.
Si ces contraintes sont vérifiées, chaque surface critique s’appuie sur exactement trois arêtes
de polygones, et une droite poignardante extrême s’appuie sur quatre arêtes. Ces arêtes, sur les-
quelles s’appuient les surfaces critiques et les droites poignardantes extrêmes, sont appelées les arêtes
génératrices d’une surface critique ou d’une droite poignardante extrême. On distingue deux types de
surfaces critiques : les surfaces EEE (pour Edge-Edge-Edge) et les surfaces V E (pour Vertex-Edge).
Les surfaces EEE correspondent à trois arêtes génératices gauches : la surface est une quadrique
réglée (cf. Figure 3.6 (a)).
Les surfaces V E sont générées lorsque deux des arêtes génératrices possèdent une intersection :
la surface est un plan, et est donc générée par un sommet et une arête (cf. Figure3.6 (b)).
(a) (b)
F IG . 3.6: Dans une scène polygonale, les surfaces critiques sont des quadriques (a) qui peuvent d égénérer en
un plan (b).
Les surfaces critiques ne sont pas infinies, et sont délimitées par les droites poignardantes extrêmes
(cf. Figure 3.7).
Toute droite poignardante extrême est située à l’intersection de différentes surfaces critiques (ce
sera toujours le cas puisque les surfaces critiques sont des surfaces réglées). Il en existe de trois types :
– entre 2 sommets de 2 polygones distincts (droite VV )
– entre un sommet d’un polygone et deux arêtes gauches de deux autres polygones (droite V EE)
10 Dans les scènes d’objets lisses, il existe aussi des surfaces critiques qui correspondent à des ensembles de droites
tangentes aux deux objets et qui sont coplanaires.
11 Par définition, des objets sont en position génériques s’ils sont placés de telle sorte qu’aucun cas dégénéré ne survienne.
– entre 4 arêtes de différents polygones (droite EEEE).

La Figure 3.7 montre trois surfaces critiques S0 , S1 , S2 de type V E, ainsi que les droites poignar-
dantes extrêmes e0 ; e1 ; e2 ; e4 de type VV à leur intersection.
F IG . 3.7: Les intersections des surfaces critiques sont les droites poignardantes extr êmes.
Grâce aux suppositions de généricité, les surfaces critiques définies dans le paragraphe précédent
s’appuient sur exactement 3 arêtes génératrices et les droites poignardantes extrêmes sur exactement
4 arêtes. En pratique, ces hypothèses de généricité ne sont que très rarement vérifiées : les surfaces
critiques comme les droites poignardantes extrêmes peuvent s’appuyer sur un nombre quelconque
d’arêtes, en raison des alignements des objets de la scène (cf. Figure3.8). Les algorithmes de visibilité
devront être robustes vis-à-vis de ces dégénérescences s’ils doivent être capables de traiter autre chose
que des cas théoriques synthétisés pour l’occasion [132, 52, 70].
F IG . 3.8: Exemple de situation dégénérée : la droite poignardante extr ême s s’appuie sur plus de quatre ar êtes,
puisqu’elle contient les arêtes e1 , e2 , e3 et e4 ainsi que les sommets V1 et V2 (d’après Durand [54])
.
2.1.3.3 Nombre de surfaces critiques et de droites poignardantes Dans les scènes d’objets
lisses, il est possible de créer des scènes arbitrairement grandes qui ne possèdent pas de droite poi-
gnardante ni de surface critique : il suffit de construire une scène telle que deux objets au maximum
soient visibles de manière tangentielle [54]. Contrairement au cas des objets lisses, il existera toujours
des droites poignardantes (resp. des surfaces critiques) dans une scène polygonale puisque chaque
paire de sommets et chaque paire sommet/arête en génèrent. Potentiellement, dans une scène com-
portant n arêtes, il existe O(n4 ) droites poignardantes extrêmes puisque toute combinaison de 4 arêtes
génère potentiellement 2 droites poignardantes. Cependant, cette borne est très pessimiste, car dans
une scène typique, un grand nombre de ces droites sont bloquées par d’autres primitives de la scène.
De même, il existe potentiellement O(n3 ) surfaces critiques puisque toute combinaison de 3 arêtes en
génère potentiellement une. Dans le cas d’une scène particulière composée de sphères alignées, cette
borne a été ramenée à une complexité linéaire [49], borne beaucoup plus proche de ce qui est observé
dans la pratique.
2.1.4 Utilisation du graphe d’aspect pour le calcul de vues

La première implémentation d’un algorithme de construction du graphe d’aspect pour des objets
polygonaux quelconques est due à Gigus, mais sa méthode était limitée aux vues orthographiques [69].
Les premiers algorithmes permettant de créer un graphe d’aspect en projection perspective furent pro-
posés par Plantinga [128] ; nous renvoyons le lecteur au travail de Schiffenbauer [140] pour un état
de l’art plus détaillé concernant la construction des graphes d’aspect. Leur première application, qui
motiva leur développement, fut la reconnaissance d’objets [92, 93]. Pour reconnaı̂tre deux objets si-
milaires, l’idée consistait à comparer leur graphe d’aspect, ce qui revient à comparer des vues 2D des
objets et la façon dont ces vues sont <agencées> entre elles. Plantinga et al. ont montré que les graphes
d’aspect pouvaient également être utilisés pour déterminer les surfaces visibles dans une scène, en ne
calculant que la sous-partie de la partition <VSP> correspondant aux apparitions/disparitions d’objets
dans l’image [79]. Cette approche résout le problème du précalcul complet et exact de visibilité de
manière théorique : puisque toutes les vues de la scène sont encodées, il suffit de localiser la caméra au
sein de la partition <VSP> lors de la navigation interactive, puis d’afficher la vue associée. Malheu-
reusement, cette approche a une complexité prohibitive, car le nombre de régions du graphe d’aspect
est O(n9 ) [128]. De plus, il semble difficile de trouver un algorithme opérationnel de calcul de graphe
d’aspect dans des scènes complexes.
Coorg et al. ont proposé une méthode alternative [40] : plutôt que de calculer et de stocker toutes
les vues de la scène, ils proposent de maintenir la vue courante de manière incrémentale, en fonction
des déplacements de la caméra. L’aspect de la scène ne doit en effet être modifié que lorsque la caméra
traverse une (plusieurs) surface(s) critique(s). Etant donné les difficultés d’une telle approche dans
le cas général (surfaces critiques non planes, et en très grand nombre), Coorg et al. ne maintiennent
qu’une partie des surfaces critiques : ils ne calculent que les surfaces critiques planes, et ne considèrent
que celles générées par des objets considérés individuellement. Cette approche, qui ne détecte qu’une
partie des occultations existantes, consiste donc à maintenir de manière incrémentale une version
simplifiée et linéarisée du graphe d’aspect.
2.2 La structure de données <Asp>

Afin de tenir compte des occultations lors du calcul du graphe d’aspect de scènes quelconques,
Plantinga propose d’utiliser une structure de données intermédiaire, appelée <Asp> [128,127]. L’idée
générale consiste à exprimer chaque rayon traversant la scène dans un espace dual 5D. Soit A et B
deux objets définis dans R3 . La représentation dans l’espace dual de l’ensemble des rayons traversant
A est appelée l’<asp> de l’objet A, et nous le notons Asp(A). Plantinga a montré que l’intersection
des <asp> des deux objets A et B, Asp(A) \ Asp(B), représentait l’ensemble des rayons qui traver-
saient simultanément A et B [128, 127]. Si B est un écran placé devant A, l’ensemble des rayons qui
atteignent A sans être bloqués par B est donc égal à Asp(A) (Asp(A) \ Asp(B)), autrement dit à
Asp(A) Asp(B). Plantinga suggère donc que cet ensemble de rayons non bloqués peut être obtenu
par des opérations de soustraction dans l’espace dual. Les frontières de l’<asp> correspondent aux
surfaces critiques, nécessaires à la construction du graphe d’aspect. A notre connaissance, aucune
implémentation de l’<asp> n’est connue, sans doute à cause de la difficulté de réaliser des opérations
géométriques dans l’espace dual choisi par Plantinga. Cependant, l’idée de soustraire des ensembles
de droites dans un espace dual a été utilisée récemment avec succès par Nirenstein et al. [120], dans
le cadre de l’<occlusion culling> (cf. section 3.2.3).
2.3 Arrangement d’hyperplans dans l’espace de Plücker

Pour accélérer les requêtes de lancer de rayons 12 , Pellegrini propose de calculer un arrangement
d’hyperplans dans l’espace de Plücker [125] 13 . Cet arrangement est appelé <arrangement dual> par
Frédo Durand [54], mais nous utilisons ici la dénomination plus correcte <d’arrangement d’hyper-
plans dans l’espace dual> proposée par Xavier Goaoc [70].
Soit une scène polygonale dans R3 . La droite support de chacune des arêtes est convertie en
un hyperplan dans l’espace dual de Plücker à l’aide de l’équation (2.11). L’ensemble d’hyperplans
définit un arrangement dans l’espace de Plücker. Cet arrangement est composé de polyèdres, dont les
intersections avec la quadrique de Plücker représentent les droites réelles. L’approche de Pellegrini
consiste à calculer l’arrangement complet d’hyperplans dans l’espace de Plücker, puis à associer à
chacun des polyèdres P de l’arrangement la liste des primitives de l’espace R3 qui sont traversées par
les droites représentées par P . Il montre que le problème du lancer de rayon est ramené à un problème
de localisation, qui peut être résolu en temps logarithmique : il suffit de déterminer à quel polytope
de l’arrangement appartient la droite support du rayon pour connaı̂tre la liste des primitives traversées
par le rayon. Cette approche est intéressante car elle montre comment utiliser l’espace de Plücker pour
représenter des ensembles de droites dans l’espace R3 , et montre également comment précalculer et
regrouper les ensembles de droites en fonction de leur position par rapport aux primitives de la scène.
Cependant, comme tout calcul d’arrangement, cette approche nécessite un temps O(n4 ), et est prohi-
bitive en pratique [118]. De plus, elle a le désavantage de ne pas tenir compte des occultations [54].
En effet, l’arrangement d’hyperplans contient beaucoup de polyèdres qui représentent des ensembles
de droites traversant des primitives de la scène ; ces polyèdres devraient être éliminés si l’on tenait
compte des occultations. Comme nous le verrons dans la section 3.2.3, l’idée de représenter l’occul-
tation dans l’espace de Plücker a été reprise par Nirenstein et al. et par Jiřı́ Bittner pour le précalcul
exact de visibilité depuis une région [120, 20].
2.4 Méthodes de visibilité globales

Les méthodes de visibilité globales ont pour but de représenter l’entièreté de l’information de
visibilité d’une scène, afin de permettre un traitement unifié de toutes les opérations nécessitant de
résoudre des requêtes de visibilité (élimination des faces masquées, calculs d’éclairage,...) [20, 70].
Ces approches consistent à encoder les relations de visibilité existant entre les différents objets de
la scène. Leur intérêt pratique est limité pour l’accélération de l’affichage, mais elles constituent un
cadre théorique adéquat pour les travaux de visibilité. Nous présentons un aperçu des méthodes de
calcul global de visibilité, mais renvoyons le lecteur à la thèse de Xavier Goaoc pour un état de l’art
plus complet [70].
12 Pour rappel, le lancer de rayons consiste à déterminer la liste des primitives de la scène qui sont traversées par une
demi-droite.
13 Une introduction aux coordonnées de Plücker et aux arrangements d’hyperplans est présentée dans le chapitre 2
(pages 24 et 22).
2.4.1 Complexe de visibilité

Le complexe de visibilité a été introduit en 2D par Pocchiola et al. [130], et fut ensuite étendu au
cas 3D par Durand et al. [55, 53, 54]. La notion fondamentale sur laquelle repose le complexe est celle
de <segment libre maximal> : les segments libres maximaux sont des segments de longueur maxi-
mum qui ne rencontrent aucun des objets de la scène. De manière plus intuitive, il s’agit de segments
dont chacune des extrémités appartient à un objet de la scène, et qui ne coupent l’intérieur d’aucun
autre objet. Par définition, le complexe de visibilité est la partition des segments libres maximaux en
fonction des objets qu’ils touchent à leurs extrémités. Il est plus simple de décrire le complexe de
visibilité dans un espace dual 14 , de sorte que la droite support de chaque segment libre maximal cor-
responde à un point dans l’espace dual. Dans l’espace dual, chaque face du complexe de dimension
maximale15 regroupe un ensemble de segments libres qui touchent les mêmes objets [54].
Dans le plan, une face du complexe est un polygone (cf. Figure3.9), et des algorithmes optimaux
existent pour le calculer [132]. Le complexe de visibilité a été utilisé avec succès comme méthode
d’accélération pour le lancer de rayons [30], pour le maintien de vue de manière incrémentale [132],
ainsi que pour le calcul de radiosité [122].
F IG . 3.9: Complexe de visibilité 2D.(a) Scène 2D, composée de trois objets. (b) Une face du complexe de
visibilité, dans l’espace dual, correspondant à l’ensemble des segments libres entre les arêtes AB et CD.
La situation est plus complexe dans l’espace R3 , car il nécessite d’utiliser un espace dual 4D
(cf. rappel page 24). De plus, Durand et al. [53] ajoutent une pseudo-dimension supplémentaire à
leur espace dual, afin de distinguer les segments libres maximaux qui appartiennent à la même droite
support. Mais comme les auteurs le mentionnent, cette paramétrisation n’est utilisée qu’à des fins
d’illustration, et le complexe de visibilité est une notion générale qui peut être utilisée avec d’autres
paramétrisations. Ainsi, Xavier Goaoc représente le complexe de visibilité dans l’espace de Plücker.
Pour ce faire, il montre que l’arrangement d’hyperplans dans l’espace dual de Pellegrini (cf. section
2.3) peut être vu comme la projection du complexe de visibilité depuis l’espace des segments libres
maximaux dans l’espace dual de Plücker [70].
A l’heure actuelle, les algorithmes de construction du complexe de visibilité en sont encore au
stade théorique [55,70], principalement à cause des difficultés algorithmiques et théoriques soulevées.
Citons deux exceptions notables : l’algorithme proposé par Jiřı́ Bittner [20] et celui proposé par Ni-
renstein et al. [120], dans le cadre du calcul de visibilité depuis une région, dont les résultats peuvent
14 La notion d’espace dual désigne ici le procédé consistant à effectuer les calculs dans un espace différent de l’espace
dans lequel la scène est représentée.
15 Une face de dimension maximale dans l’espace dual est une face de dimension d, dans laquelle d est la dimension de
l’espace dual.
être vus comme une sous-partie du complexe de visibilité [120]. Notons également les travaux de
Chrisanthou et al. [31], qui décrivent une structure de données qui peut être vue comme une version
discrétisée du complexe de visibilité [54].
2.4.2 Squelette de visibilité

Le squelette de visibilité a été proposé par Durand et al. comme étant une version simplifiée du
complexe de visibilité, comparativement plus facile à manier et utilisable en pratique [56, 54]. Les
auteurs le définissent au sens du squelette dans la théorie des polyèdres : le squelette de visibilité est
le 1-squelette du complexe de visibilité, c’est-à-dire les éléments de dimension 0 (ses sommets) et 1
(ses arêtes).
Comme tous les 1-squelettes, le squelette de visibilité se représente naturellement sous la forme
d’un graphe planaire. Dans ce cas, les nœuds du graphe sont les droites poignardantes extrêmes, et ses
arcs sont les surfaces critiques16 . En effet, étant donné que les droites poignardantes extrêmes sont les
lieux d’intersection des surfaces critiques, plusieurs arcs du graphe aboutissent à chacun des sommets
(cf. Figure 3.10).
(a) (b) (c)
F IG . 3.10: Squelette de visibilité (image d’après [54]) (a) La surface critique P1 e1 est délimitée par les deux
droites poignardantes extrêmes P1 P2 etP1 P3 . (b) Une seconde surface critique P1 e2 , délimitée également par la
droite poignardante extrême P1 P2 . (c) Le squelette de visibilité correspondant : les nœuds du graphe sont les
droites poignardantes extrêmes, qui sont connectées entre elles par les surfaces critiques.
Le squelette de visibilité peut être construit indépendamment du complexe de visibilité, d’où son
intérêt pratique. Dans sa version originale, le squelette de visibilité est calculé de la manière sui-
vante [56] :
– calcul des nœuds du graphe : toutes les droites poignardantes extrêmes de la scène sont cal-
culées, en examinant tous les quadruplets d’arêtes et en vérifiant pour chaque quadruplet s’il
supporte une (ou éventuellement deux) droite(s) poignardante(s) extrême(s).
– les arêtes du graphe sont créées à l’aide d’un <catalogue d’adjacences>, qui permet de déter-
miner sans ambiguı̈té les nœuds qui doivent être reliés par une arête.
Pour obtenir une implémentation robuste du squelette de visibilité, Duguet et al. [52] ont ensuite
supprimé le catalogue, qui imposait que la scène soit exempte de toute dégénérescence. Néanmoins,
la combinatoire du squelette n’était pas garantie par cette approche, c’est pourquoi Xavier Goaoc a
développé un algorithme robuste de calcul du squelette de visibilité, qui garantit la structure combina-
16 Même si les arcs du squelette de visibilité et les arcs du graphe d’aspect représentent tous deux les surfaces critiques
de la scène, la ressemblance entre les deux structures de données s’arrête là.
toire du squelette [70]. Cet algorithme est basé sur un algorithme de balayage de la scène à l’aide de
plans tournant autour des arêtes des polygones, avec un maintien incrémental du squelette de visibilité
2D dans le plan de balayage.
2.5 Discussion
Un graphe d’aspect encode toutes les vues possibles d’une scène ; il résout donc le problème du
précalcul de la visibilité sur le plan théorique. Bien qu’elle ait été utilisée pour la reconnaissance
d’objets en vision, cette approche semble prohibitive lorsque la taille de la scène augmente, car la
complexité d’un graphe d’aspect est O(n9 ) [128]. Les graphes d’aspect ne sont donc pas utilisés pour
l’<occlusion culling>, dont l’objectif est d’accélérer l’affichage de scènes complexes. Les graphes
d’aspect ont cependant fourni un cadre théorique adéquat pour l’étude de la visibilité (notamment par
l’étude systématique des surfaces critiques), et ont permis le développement des méthodes de visibi-
lité globales, telles que le complexe de visibilité [55, 70]. Ces techniques proposent de résoudre tous
les problèmes de visibilité d’une manière unifiée, en encodant les relations de visibilité existant entre
toutes les primitives de la scène. Contrairement aux graphes d’aspect, elles ne stockent plus directe-
ment les vues de la scène : à la place, elles travaillent dans un espace dual. Au sein de ce dernier, elles
considèrent l’ensemble des droites qui traversent une scène, et les regroupent en fonction des objets
touchés. L’information calculée contient, entre autres, la description des surfaces critiques, et c’est
pourquoi ces méthodes sont en théorie des solutions exactes de précalcul de l’occultation puisqu’elles
permettent de déterminer la liste des objets visibles depuis n’importe quel point de l’espace navi-
gable. Malheureusement, les difficultés sous-jacentes sont nombreuses, tant du point de vue théorique
(problème d’arrangement d’hyperplans et de localisation dans un espace 5D) que du point de vue
de l’implémentation (complexité algorithmique, problèmes de robustesse). Même si ces structures
de données ont déjà démontré leur utilité pour le calcul de l’éclairage [122, 56, 52], leur construc-
tion en tant que telle est problématique : à titre d’exemple, il n’existe à notre connaissance aucune
implémentation connue du complexe de visibilité 3D [70]. De même, il n’existe aucune algorith-
mique efficace pour l’élimination des objets masqués à l’aide de ces structures de données. Mais des
solutions théoriques commencent à apparaı̂tre pour la création de structures de visibilité globales 7[ 0],
et nul doute que ces approches fourniront une solution unifiée aux problème de visibilité (dont celui
de l’élimination efficace des objets occultés).
Les difficultés liées au calcul de visibilité rendant le précalcul exact hors de portée dans le cadre
de l’<occlusion culling>, les approches utilisées dans la pratique encodent la visibilité de manière
approchée, à l’aide de techniques plus pragmatiques. Ce sont ces méthodes que nous étudions dans
les deux sections suivantes.
3 Encodage de la visibilité sous la forme de <PVS>

3.1 Introduction
Dans un scénario de visualisation interactive, il existe une infinité de points de vue accessibles
par l’utilisateur. Les méthodes de <PVS> discrétisent le problème en découpant l’espace navigable
en cellules. Le précalcul proprement dit consiste à déterminer et à stocker l’ensemble des primitives
visibles depuis chacune des cellules (c-à-d le <PVS> des cellules), à l’aide d’un algorithme de visibi-
lité depuis une région. Lors de la navigation interactive, la caméra est localisée au sein de la partition,
et seuls sont affichés les objets visibles associés à la cellule où elle se trouve.
Considérons une des régions de la partition ; le calcul de visibilité depuis la région consiste à
déterminer l’ensemble des primitives telles qu’il existe au moins un segment de droite joignant un
point de la primitive et un point de la région, et qui ne rencontrent pas d’autre primitive. Ce problème
peut être vu comme une extension directe d’un algorithme de visibilité depuis un point. La Figure3.11
représente une scène 2D, et soit un point P depuis lequel on considère l’ensemble des objets visibles
(Figure 3.11(a)), puis l’ensemble des objets visibles depuis une région R contenant P (Figure3.11(b)).
(a) (b)
F IG . 3.11: (a)Visibilité depuis un point. (b) Visibilit é depuis une région. Pour simplifier la figure, seules
les droites séparant des zones de pleine lumi ère, d’ombre et de pénombre ont été représentées. Les zones
dénommées <Ombre(fusion)> sont des zones d’ombre r ésultants de la fusion de zones de p énombre (cf. Fi-
gure 3.12).
Pour le calcul de visibilité depuis P, l’analogie avec la source lumineuse consiste à remplacer P par
une lampe ponctuelle. Les écrans créent des ombres, qui se combinent entre elles. Les objets masqués
sont ceux situés dans les zones d’ombre. Dans cette scène simple, seuls les objets O0 et O8 seront
visibles depuis P (O8 est totalement visible et O0 n’est que partiellement visible). Pour le calcul de
visibilité depuis une région, l’analogie consiste à remplacer R par une lampe étendue. Contrairement
au cas d’une lampe ponctuelle, des zones de pénombre apparaissent, définies comme des régions de
l’espace qui ne <voient> qu’une partie de la source lumineuse. Seuls les objets dans l’ombre des
écrans sont effectivement masqués. Lors de la navigation interactive, l’ensemble des objets visibles
depuis un point (le centre optique de la caméra) situé dans la région R sera approché par l’ensemble des
objets visibles depuis cette région. Une méthode exacte détectera que l’ensemble des objets visibles
depuis R est fO0 ; O2 ; O3 ; O7 ; O8 g. Si l’utilisateur se situe au point P défini dans la section précédente,
on constate donc que les objets fO2 ; O3 ; O7 g seront affichés inutilement à cause de l’utilisation de la
région R pour approcher la visibilité du point P. Il s’agit de la sur-conservativité due à la partition.
3 Encodage de la visibilité sous la forme de <PVS> 47
La plupart des méthodes de visibilité depuis une région ne sont pas capables de calculer de manière
exacte l’ensemble des objets visibles depuis R. Souvent, seule une partie des objets masqués est
détectée et il en résulte une sur-conservativité supplémentaire, que nous appelons la sur-conservativit́e
due à la méthode. La raison principale de l’utilisation de ces méthodes approchées est que le problème
de visibilité depuis une région est beaucoup plus ardu que celui de la visibilité depuis un point. En
effet, d’un problème 2D (on peut le résoudre dans une image), nous sommes passé à un problème 5D
(chaque rayon lumineux quittant la région possède deux degrés de liberté pour sa direction et trois
degrés de liberté pour son origine).
De plus, les pénombres créées par différents écrans se combinent entre elles pour former des
ombres, et il faut être capable d’en tenir compte pour détecter l’ensemble des occultations. Considérons
une scène composée d’un ensemble d’objets, et intéressons-nous à l’un d’entre eux en particulier, que
nous notons R, et que nous remplaçons par une source lumineuse. Les autres objets sont notés Oi (cf.
Figure 3.12(a)).
(a) (b) (c)
F IG . 3.12: (a) Ombres et pénombres créées par les écrans Oi considérés individuellement. (b) Tous les rayons
lumineux à destination de P4 sont interceptés par les écrans O1 et O3 . (c) P4 sera effectivement dans l’ombre
des écrans si l’on tient compte de la fusion des p énombres générées par les écrans O1 et O3 , qui se combinent
pour former une zone d’ombre (ph énomène de fusion des pénombres).
Depuis un point situé en pleine lumière, tel que le point P1 , l’objet R est entièrement visible.
Depuis un point situé dans une zone de pénombre, tel que le point P2 , R n’est que partiellement vi-
sible. Finalement, R n’est pas du tout visible depuis le point P3 , situé dans l’ombre de l’écran O1 .
Considérons maintenant le point P4 : comme on le constate à la Figure 3.12(b), l’ensemble des rayons
lumineux qui sont interceptés par P4 sont bloqués par des écrans ; R est donc occulté par rapport à
P4 . Le cas de figure présenté illustre la difficulté majeure du calcul de visibilité depuis une région :
tous les rayons lumineux ne sont pas bloqués par le même écran. Reprenons notre analogie. Dans la
Figure 3.12(a), les écrans sont considérés de manière individuelle, et P4 est situé dans la pénombre
de l’écran O1 et dans la pénombre de l’écran O3 . Dans la Figure 3.12(c), l’ensemble des écrans est
considéré simultanément pour la génération des ombres et des pénombres : les pénombres se com-
binent, et génèrent une nouvelle zone d’ombre, contenant entre autres le point P4 . Dans la plupart des
scènes, la majorité des zones d’ombre est générée par ce processus de fusion des pénombres, surtout
lorsque les sources lumineuses sont plus étendues que les écrans [115]. Si l’on n’en tient pas compte,
seule une petite partie des occultations est détectée, et il en résulte une sur-conservativité importante.
Mais réaliser la fusion des pénombres n’est pas trivial, car il est nécessaire de combiner l’effet de
plusieurs écrans considérés simultanément. On dit des méthodes qui y parviennent qu’elles réalisent
la fusion des écrans.
Etant donné les difficultés soulevées, les premières méthodes capables de réaliser la fusion complè-
te des écrans dans les scènes 3D ne sont apparues que récemment [120, 20], et des méthodes ap-
prochées ont été utilisées auparavant. Nous suivons Nirenstein et al. [120], et classons en quatre
catégories les algorithmes de visibilité depuis une région, en fonction du résultat qu’ils produisent
(cf. Table 3.1).
– Les méthodes conservatives peuvent surestimer le PVS, mais ne le sous-estiment jamais. Avec
ces méthodes, des primitives invisibles peuvent être considérées comme visibles, ce qui entraı̂ne
une sur-conservativité et des performances non optimales, mais elles n’occasionnent jamais
d’erreur dans l’image (faux positifs). Dans l’exemple de la Figure3.11, une méthode conserva-
tive considérant chaque écran de manière individuelle déterminera que seuls les objets fO5 ; O6 g
sont masqués. Ces méthodes réalisent donc une fusion incomplète des écrans.
– Les méthodes agressives peuvent sous-estimer le PVS, mais ne le surestiment jamais. Aucune
primitive invisible n’est déclarée visible, ce qui signifie que les performances durant la navi-
gation interactive sont optimales. Cependant, ces méthodes peuvent occasionner des erreurs
dans l’image, puisque des objets peuvent manquer suite à la sous-estimation du PVS (faux
négatifs). Dans notre exemple, une méthode agressive considérera de manière erronée que les
objets fO2 ; O3 g, très peu visibles, sont masqués. Ces méthodes réalisent une fusion incorrecte
- et abusive - des écrans.
– Les méthodes approximatives surestiment et/ou sous-estiment le PVS. Elles entraı̂nent donc des
erreurs dans l’image, ainsi que l’affichage inutile d’objets (faux positifs et faux négatifs). Ces
méthodes réalisent également une fusion incorrecte des écrans.
– Les méthodes exactes fournissent le PVS exact, c’est-à-dire l’union des primitives visibles de-
puis tous les points de la région et sont donc optimales du point de vue du temps d’affichage,
tout en fournissant un résultat correct 17 . Ces méthodes réalisent la fusion complète des écrans.
Méthode Qualité de l’image Sur-conservativité Résultats Fusion des écrans

Conservative Correcte Oui Faux positifs Partielle
Agressive Erreur Non Faux négatifs Incorrecte
Approximative Erreur Oui Faux positifs/négatifs Partielle/incorrecte
Exacte Correcte Non Exacts Complète
TAB . 3.1: Classification des algorithmes de calcul de visibilit é depuis une région (dans le tableau, la colonne
<sur-conservativité> désigne la sur-conservativité due à la méthode).
Nous présentons dans la section 3.2 le principe des algorithmes de visibilité depuis une région
existant pour chacune de ces catégories. Nous étudions le problème de la partition de l’espace navi-
gable en cellules dans la section 3.3.
3.2 Algorithmes de visibilité depuis une région

3.2.1 Techniques conservatives
3.2.1.1 Ecrans individuels Ces techniques ne détectent que les occultations créées par les écrans
considérés individuellement, et ne réalisent aucune fusion de pénombres [44, 138, 116] : étant donné
une région de l’espace R et un objet S, S n’est considéré comme masqué que s’il existe un objet T qui
17 Elles peuvent évidemment entraı̂ner l’affichage superflu de primitives puisque la visibilité depuis un point est approchée
par la visibilité depuis une région (sur-conservativité due à la partition).

bloque tous les rayons existant entre R et S. Ce test est très simple à réaliser si les cellules, les objets et
les écrans sont convexes : en effet, il suffit de tester si l’ensemble des segments de droite joignant les
sommets de R et les sommets de S sont bloqués par un même écran (cf. Figure3.13(a)). Les méthodes
utilisant ce principe considèrent chacun des objets de la scène et testent s’il existe au moins un écran
convexe qui occulte entièrement l’objet [44, 138]. Si ce n’est pas le cas, l’objet est considéré comme
étant potentiellement visible depuis la région.
L’utilité de ces méthodes est assez limitée, car elles ne réalisent pas de fusion de pénombres et
nécessitent de ce fait la présence d’écrans convexes de grande taille par rapports aux cellules 1[ 15].
Cette condition est difficile à vérifier lorsque la densité des maillages augmente, puisqu’il faudrait uti-
liser beaucoup de cellules, entraı̂nant une explosion du temps de calcul et de la mémoire de stockage.
Poulin et al. ont relâché cette contrainte en proposant un algorithme de regroupement, pour former
des écrans convexes de grande taille à partir du maillage d’un objet [98]. Cette technique est prise en
défaut lorsque les écrans sont concaves. Brunet et al. ont montré que la condition de convexité des
écrans était trop restrictive, et qu’une condition suffisante était que l’ombre de l’écran soit convexe
pour que le test de visibilité à l’aide de rayons soit conservatif [26]. Pour exploiter ce test, les auteurs
extraient des contours polygonaux non convexes en 3D, appelés <Hoops>, qui ont une apparence
convexe depuis n’importe quel point de la région (cf. Figure3.13(b)). Les auteurs décrivent également
un procédé permettant de combiner l’ombre de plusieurs <Hoops>, correspondant à différents écrans,
et donc de détecter des objets dont l’occultation résulte de la présence de plusieurs écrans.
Navazo et al. ont montré qu’il était également possible de détecter l’occultation créée par une
surface à l’aide de prédicats topologiques, en se passant complètement de toute notion de convexité
pour l’écran et son ombre [116] (cf. Figure 3.13(c)). Soit deux objets R et S et un écran T placé
entre eux. Leur approche, appelée <ShieldTester>, consiste à tracer un rayon entre un sommet de R
et un sommet de S, et à tester si un prédicat topologique est vérifié par T . Etant donné que chaque
écran T est considéré individuellement, cette approche ne réalise malheureusement aucune fusion des
pénombres, et son utilité est donc également limitée.
(a) (b) (c)
F IG . 3.13: (a) Ecran convexe : R et S sont mutuellement masqu és si tous les rayons joignant les sommets de R et
de S sont bloqués par T . (b) Un <Hoops> est une ligne polygonale non convexe, mais qui à l’apparence convexe
depuis n’importe quel point de R. (c) <ShieldTester> permet de d étecter que les deux boı̂tes sont masquées par
l’écran concave (image provenant de [116]).
3.2.1.2 Techniques volumiques Plutôt que d’utiliser directement les maillages comme écrans, les
techniques volumiques utilisent l’intérieur des objets [6, 139, 167] : avant le traitement, la scène est
voxelisée 18 , c’est-à-dire que sa représentation surfacique polygonale est convertie en voxels. L’avan-
tage est d’utiliser une version épurée du modèle, car les détails sont éliminés lors de la conversion.
18 La <voxelisation> consiste à transformer des données surfaciques en données volumiques, composées de <voxels>.
Un <voxel> est l’analogue 3D du pixel, et est un élément de volume parallélipipédique.

Evidemment, ces méthodes ne fonctionnent que si les objets possèdent un intérieur bien défini. Plu-
sieurs méthodes basées sur cette représentation ont été proposées.
F IG . 3.14: Techniques volumiques (a) Les ombres des écrans sont discrétisées, et combinées entre elles dans
l’espace 3D discret [139]. (b) La méthode ne réalise pas la fusion des pénombres, la partie de l’ombre dessin ée
en couleur n’est pas détectée
A partir de l’ensemble de voxels, Andujar et al. extraient un ensemble réduit de boı̂tes de grandes
tailles, se recouvrant mutuellement, et pouvant être utilisées comme écran [6].
Schauffler et al. traitent le problème de manière discrète, et calculent des versions discrètes des
cônes d’ombre générés par les voxels. Cette technique leur permet de combiner explicitement l’ombre
générée par plusieurs objets dans l’espace 3D discrétisé [139] (cf. Figure 3.14(a)). Elle permet de fu-
sionner les ombres des écrans, mais pas leurs pénombres [47] : c’est pourquoi elle ne détectent qu’une
sous-partie des objets masqués (cf. Figure 3.14(b)). Yagel et al. proposent un algorithme similaire,
mais qui est plus efficace car il permet de tenir compte de l’effet combiné de plusieurs écrans [167].
Notons que les techniques volumiques n’imposent pas une discrétisation régulière : Schauffler en tire
parti en utilisant un <octree> pour représenter les ombres de manière hiérarchique.
Remarque : Les <Hoops> présentés dans la section précédente peuvent également être classés
parmi les techniques volumiques, car les contours polygonaux sont extraits à partir d’une
représentation volumique de la scène. Notons que l’utilisation de <Hoops> permet en théorie de
détecter de plus grands volumes d’ombre que la méthode de Schauffler.
3.2.1.3 Opérateurs de projections étendues Le calcul de visibilité depuis un point est intrin-
sèquement 2D 19 et peut se résoudre dans une image. Au contraire, le calcul de visibilité depuis une
région est 5D 20 , et il nécessite des structures de données multi-dimensionnelles pour être résolu de
manière exacte. A l’instar du calcul de visibilité depuis un point, Durand et al. proposent de calculer
la visibilité depuis une région dans une image [57], en utilisant des opérateurs de projection étendus.
Grâce à ces opérateurs particuliers, les tests d’occultation sont effectivement réalisés en 2D, dans
19 Chaque rayon de vue a 2 degrés de liberté qui définissent sa direction.
20 Chaque rayon de vue a 2 degrés de liberté pour sa direction et 3 degrés de liberté pour son origine.
l’image formée sur un plan de projection : pour calculer l’occultation d’une région, la scène est balayée
avec des plans de projection perpendiculaires aux axes du système de coordonnées. Les opérateurs de
projection sont définis de telle sorte que les projections obtenues représentent de manière conservative
les occultations générées par les écrans, et ce depuis n’importe quel point de la région. Les projections
étendues sont différentes pour les écrans et pour les receveurs :
– écran : la projection étendue est égale à l’intersection des projections 2D de l’écran depuis tous
les points de la cellule.
– receveur : la projection étendue est égale à l’union de toutes les projections 2D du receveur
depuis tous les points de la cellule.
Une condition nécessaire (mais non suffisante) pour qu’un receveur soit masqué est que sa projec-
tion étendue soit contenue dans la projection étendue des écrans.
Même si cette méthode permet de tenir compte de l’effet combiné des écrans dans certaines configu-
rations, elle n’effectue pas la fusion complète des pénombres, et son efficacité est discutable lorsque
la taille des écrans diminue [118].
Des concepts similaires ont également été développés par Lim et al., la notion de projections
étendues étant formalisée à l’aide de notions d’intelligence artificielle et de logique floue [103].
3.2.1.4 Réduction de la géométrie Wonka et al. ont introduit l’idée de <réduire> les écrans avant
de calculer la visibilité depuis un point P [165,166] : ils ont montré que la visibilité ainsi calculée était
valable pour tout point appartenant à un voisinage centré en P. En d’autres termes, ils ont montré que
l’on pouvait approcher l’ombre générée par une lampe étendue au moyen d’une lampe ponctuelle, à
condition d’utiliser des écrans réduits à la place des écrans originaux. La méthode de réduction pro-
posée par les auteurs consiste à enlever l’épaisseur d’une sphère de rayon r sur tout le bord des écrans :
la visibilité calculée depuis un point P est alors valable pour tout point situé dans une sphère de rayon
r centrée en P [165]. Pour calculer la visibilité depuis une région, les auteurs calculent la visibilité
ponctuelle depuis un ensemble de points d’échantillonnage, choisis de telle sorte que leurs régions
de validité se recouvrent. L’union des objets visibles depuis l’ensemble des points d’échantillonnage
fournit une approximation conservative du PVS de la région (cf. Figure 3.15). L’avantage de cette
méthode est de réaliser la fusion (partielle) des écrans.
F IG . 3.15: Réduction des écrans (a),(b)et(c) R éduction des écrans, et calcul de la visibilité depuis différents
points d’échantillonnage avec les écrans réduits.(d) L’intersection des ombres ponctuelles échantillonnées est
incluse dans l’ombre de la région ; l’union des objets visibles depuis l’ensemble des points d’ échantillonnage
est donc une approximation conservative du PVS de la r égion.
Décoret et al. ont montré que la réduction pouvait être remplacée par une opération morpholo-
gique d’érosion, et que la propriété restait valable si l’on remplaçait la sphère par un élément struc-
turant convexe [47, 48]. Grâce à ce formalisme, les auteurs ont ensuite démontré que l’on pouvait
également réduire les receveurs (et plus seulement les écrans), afin de détecter plus d’occultations. En
effet, dans de nombreux cas, l’érosion d’un objet est entièrement située dans l’ombre, alors que l’ob-
jet en lui-même est partiellement visible depuis la cellule. En 3D, toute la difficulté de cette approche
résulte dans le calcul de l’érosion : dans sa thèse de doctorat, Xavier Décoret utilise une représentation
volumique des objets pour réaliser l’érosion des objets 3D [47].
Une approche utilisant également l’idée de réduction des écrans a été proposée récemment par
Chhugani et al. [29], la réduction étant effectuée à partir des cônes d’ombre générés par les objets.
3.2.1.5 Ecrans virtuels Koltun et al. ont introduit les écrans virtuels21 afin de représenter l’occul-
tation cumulée d’un ensemble d’écrans [94]. Par définition, un écran virtuel est un polygone associé à
la région R qui n’appartient pas à la scène initiale : il est synthétisé de telle manière qu’il soit masqué
depuis tout point de R. Ces nouveaux écrans sont ensuite utilisés en lieu et place de la géométrie
initiale pour éliminer les objets masqués. Le but poursuivi est double : d’une part, offrir un calcul de
visibilité depuis une région réalisant la fusion des écrans (en effet, par construction, un écran virtuel
représente l’ombre fusionnée de plusieurs écrans), d’autre part réduire les besoins de stockage, car
seuls les écrans virtuels doivent être stockés, à la place de la liste des objets visibles. Koltun et al. pro-
posent une technique de calcul pour le cas particulier de scène 2D12 22 , basée sur les droites supports
et les droites séparatrices de la cellule et des écrans. Mais cette approche semble difficile à étendre
au cas 3D. Dans les scènes de villes, Downs et al. extraient des prismes verticaux pour représenter
l’occultation créée par les bâtiments, à partir desquels une ligne d’horizon est calculée. Tous les ob-
jets situés derrière la ligne d’horizon sont considérés comme masqués [50]. Des techniques utilisant
l’horizon, qui peut être considéré en lui-même comme un écran virtuel, ont également été utilisées
dans le cas des terrains [146, 105]. En 3D, Hua et al. utilisent un autre type d’écrans virtuels, qui se
présente sous la forme d’un ensemble de cartes de profondeur appelées <cartes globales d’occulta-
tion> et notées <GOM> 23 , dont chacun des pixels est appelé <barrière virtuelle>. Chaque barrière
est placée de telle sorte qu’elle soit effectivement masquée depuis tout point de la région [86]. Les
<GOM> sont ensuite utilisées pour détecter les objets masqués. L’avantage de cette méthode est de
permettre de découpler la complexité des écrans de la complexité de la géométrie, car la résolution
des GOM est fixe. Elle offre également de nombreuses possibilités de compression, puisque les GOM
se présentent sous la forme de cartes de profondeurs 2D. Notons que les <Hoops> peuvent également
être considérés comme des écrans virtuels [26], ainsi que les représentations volumiques utilisées pour
remplacer la géométrie dans les calculs de visibilité [6, 139, 167].
3.2.1.6 Diviser pour régner Soit un ensemble de rayons lumineux émis par une source lumineuse
volumique. Chacun des rayons possède 5 degrés de liberté : 3 coordonnées (x; y; z) pour localiser
spatialement son origine et 2 coordonnées (θ; φ) pour sa direction. Dans l’espace à 5 dimensions
(x; y; z; θ; φ), l’ensemble des rayons émis par la source représente un hypercube 24 . Les approches
<diviser pour régner> subdivisent cet hypercube de manière récursive [8, 161, 73, 1] : dans l’espace
3D, chaque <sous-hypercube> obtenu représente un faisceau lumineux, dont on calcule l’intersection
avec la géométrie de la scène. Ce faisceau est subdivisé tant que certaines conditions ne sont pas
vérifiées (faisceau possédant une intersection avec un certain nombre de primitives,...). Initialement
21 Les écrans virtuels sont également appelés <anti-portails> dans l’industrie du jeu vidéo.
22 Une scène 2D 12 est une scène que l’on peut représenter à l’aide d’une carte d’élévation. Chaque point de la carte
contient la hauteur verticale de la géométrie qui le surplombe.
23 <GOM> pour <Global Occlusion Map> en anglais.
24 Un hypercube est la généralisation du cube dans un espace à n dimensions.
appelées méthodes de classification de rayons, elles furent d’abord développées pour accélérer le
lancer de rayons [8, 1]. Wang et al. en ont ensuite utilisé le principe pour calculer la visibilité depuis
une région [161] : les faisceaux quittant la région sont subdivisés, jusqu’à ce qu’ils ne soient plus
bloqués que par une et une seule primitive. Gotsman et al. ont utilisé un principe similaire dans le
cadre des méthodes de visibilité agressives [73] (cf. section 3.2.2).
3.2.2 Techniques agressives

Les méthodes agressives ne calculent pas la visibilité de manière directe et explicite, mais l’es-
timent à l’aide d’un procédé d’échantillonnage. Mais nous avons vu que la visibilité changeait de
manière discontinue, lorsque les surfaces critiques sont traversées : c’est pourquoi la visibilité depuis
le point A ne donne aucune information sur la visibilité au point A + ε, et ce, quel que soit ε 2 R3 . A
cause de cette nature discontinue de l’information que l’on échantillonne, les méthodes de visibilité
basées sur un échantillonnage ne détecteront pas tous les objets visibles, et occasionneront des erreurs
d’affichage lors de la navigation interactive. Cependant, ces méthodes présentent un certain intérêt si
l’on parvient à réduire cette erreur et à la rendre peu perceptible, car elles sont simples à mettre en
œuvre et possèdent de bons temps de calcul [119].
La technique d’échantillonnage la plus simple consiste à générer un ensemble de rayons aléatoires
issus de la région, dont on calcule ensuite l’intersection avec les objets de la scène ; la première
primitive touchée par le rayon est considérée comme visible [73, 3, 25, 71](cf. Figure 3.16). Cohen
et al. ont proposé de masquer les artéfacts dus à l’échantillonnage à l’aide d’imposteurs 25 , dans les
scènes représentant des arbres avec des feuillages denses [36].
F IG . 3.16: Echantillonnage de la visibilit é à l’aide de rayons aléatoires issus de R. Les objets 01 ,03 ,04 et 05 sont
correctement identifiés comme étant visibles ; aucun rayon n’atteignant l’objet 0 2 , l’échantillonnage le classe
de manière erronée comme étant <masqué>.
Nirenstein et al. utilisent la technique classique de l’<item buffer> [162] pour réaliser l’échantil-
lonnage de manière efficace, à l’aide du matériel graphique [119]. En recommençant cette opération
depuis de nombreux points situés à l’intérieur de la cellule, un échantillonnage de sa visibilité est ob-
tenu. Nirenstein et al. décrivent différentes heuristiques, permettant de répartir les points d’échantillon-
nage sur la surface de la région de manière à diminuer les risques de sous-échantillonnage. Ils pro-
posent également un système de <cache> de données, permettant de réexploiter l’information déjà
calculée, afin d’éviter de devoir afficher toute la scène dans l’<item buffer>.
25 Un imposteur est un trompe-l’œil rapide à afficher, destiné à remplacer la géométrie peu visible ou éloignée.
Remarque : l’<item buffer> est une technique basée sur le <z-buffer>, qui permet de déterminer la
liste des objets visibles depuis un point P. Après avoir assigné une couleur unique à chaque primi-
tive, la scène est dessinée depuis P, à l’aide de l’algorithme classique du <z-buffer>, dans 6 images
formant un cube autour de P ; la couleur de chacun des pixels des 6 images obtenues donne la liste
des objets visibles depuis le point P.
A l’heure actuelle, il n’existe pas de méthodes de visibilité agressive permettant de garantir une
erreur bornée. Des techniques de visibilité approchées garantissant une borne sur l’erreur commise
ont cependant été proposées par Soler et al. dans le domaine du calcul global d’illumination [142,144,
143].
3.2.3 Techniques exactes

Plutôt que de résoudre le problème du calcul de visibilité directement depuis une région, les
méthodes exactes le décomposent en plusieurs problèmes de visibilité depuis une surface, plus simples
à résoudre 26 . Soit une région émettant des rayons lumineux. Chaque rayon doit traverser l’une des
faces de la frontière de la région pour la quitter. Cela signifie que l’ensemble des primitives visibles
depuis la région correspond à l’union des primitives vues par chacune des faces de la frontière (et
les primitives à l’intérieur de la région). Cela montre que le problème de visibilité depuis une région
peut être résolu uniquement à l’aide de techniques de visibilité depuis une surface. Les techniques de
visibilité depuis une surface utilisent toutes un espace dual appelé espace des droites, dans lequel les
ensembles de droites sont représentés sous la forme de polytopes (cf. chapitre2). En 2D, cet espace
dual est également bi-dimensionnel, et des algorithmes efficaces ont été proposés en 2001 [95, 24].
Comme montré récemment par Bittner et al. [19], ces algorithmes peuvent être étendus au cas 2D12 .
En 3D le problème est plus ardu, car l’espace dual des droites est de dimension quatre minimum [54] ;
toutes les approches précédentes utilisent l’espace projectif 5D de Plücker pour représenter les en-
sembles des droites [120, 20, 113]. Pour ne pas alourdir l’exposé, nous reportons l’étude de ces tech-
niques au chapitre 4, consacré à ce sujet.
Factorisation de l’information de visibilité

Dans de nombreuses scènes, la visibilité est fortement anisotrope : en raison de la pesanteur,
les scènes s’étendent principalement dans le plan horizontal, et leur complexité verticale est réduite.
Leyvand et al. baptisent ces scènes, situées entre la 2D12 et la 3D les scènes <3D + ε> [102] . Pour y
calculer la visibilité depuis une région, les auteurs proposent de factoriser le calcul en un problème
vertical et en un problème horizontal. Dans le plan horizontal, une technique de visibilité exacte est
utilisée, alors que la visibilité n’est évaluée que de manière conservative dans la direction verticale, en
représentant l’ombre verticale à l’aide de deux angles. Le résultat est une fusion complète des écrans
dans le plan horizontal et la fusion des seules ombres infinies dans le plan vertical. L’avantage de cette
méthode est sa grande rapidité d’exécution, l’implémentation proposée exploitant les fonctionnalités
récentes des cartes graphiques [102]. Elle est malheureusement limitée aux scènes <3D + ε> et ne
permet pas de traiter de scènes quelconques.
26 Le problème de visibilité depuis une surface est 4D, car le point <origine> des rayons lumineux n’a que deux degrés
de liberté, alors que la visibilité depuis une région est 5D.
3.3 Partition de l’espace navigable en cellules

Créer une partition de l’espace navigable consiste à choisir le nombre de cellules, leurs formes et
leurs positions. La solution exacte à ce problème est connue théoriquement : il s’agit de la décomposi-
tion en cellules de visibilité constante [128] : les cellules sont délimitées par les surfaces critiques, et
deux cellules voisines ne diffèrent que par l’apparition d’une primitive.
F IG . 3.17: Partition de l’espace navigable en fonction des surfaces vues. Les zones color ées représentent les
régions de visibilité constante. La légende indique les segments visibles depuis chaque cellule. Les fronti ères
entre zones de visibilité constante sont les segments critiques, dont les analogues pour la 3D sont les surfaces
critiques (seul un sous-ensemble des segments critiques est repr ésenté).
Considérons la Figure 3.17, qui représente une scène très simple dans le plan, composée de quatre
segments de droite. Les polygones de couleur représentent une partition de l’espace navigable en
cellules de visibilité constante : pour une caméra se déplaçant dans la scène, les mêmes segments
restent visibles tant que la caméra ne change pas de cellule, les apparitions et disparitions d’objets
survenant lorsque la caméra en franchit les frontières. En 2D, ces frontières sont des segments de
droite appelés segments critiques, qui correspondent aux surfaces critiques en 3D.
Comme on peut le constater, la partition n’est pas triviale, même dans un cas de figure aussi
simple :
– Les segments critiques s’arrêtent lorsqu’ils rencontrent des objets.
– Certaines régions ne sont pas convexes (par exemple le polygone 1-2-3-4).
– Il existe un grand nombre de régions de visibilité constante (on en compte déjà 19 dans cet
exemple).
– Il faut tenir compte de l’effet cumulé de plusieurs écrans pour obtenir certaines régions (problème
de la fusion des écrans).
– La situation est encore plus complexe en 3D, car les frontières entre cellules de visibilité
constante sont des surfaces du second degré (les surfaces critiques)
Des partitions de ce type existent en 2D, dans le domaine de la robotique [76], mais leur extension
en 3D est délicate et aucune partition en cellules de visibilité constante n’existe à l’heure actuelle dans
le domaine du précalcul de visibilité.
Remarque : Les graphes d’aspect et les partitions <VSP> (cf. page 35) constituent des exceptions
à cette règle, puisque la partition en cellules de visibilité constante est une sous-partie de la partition
<VSP> (la partition en cellules d’aspect constant), qui est la partition duale du graphe d’aspect. En
ce qui concerne l’<occlusion culling>, un graphe d’aspect encode trop d’informations, car toutes
les vues sont représentées, même si elles ne se diffèrencient pas par l’apparition ou la disparition
d’un objet de la scène. A titre illustratif, la Figure 3.18 compare une partition en cellules de visibilité
constante et une partition en cellules d’aspect constant. On constate que le graphe d’aspect contient
les cellules de visibilité constante, mais également de nombreuses cellules superflues du point de vue
de l’élimination des objets masqués.
(a) (b)
F IG . 3.18: (a) <Partition VSP> (partition de l’espace navigable en cellules d’aspect constant). (b) Partition en
cellules de visibilité constante : il s’agit d’un sous-ensemble de la partition en cellules d’aspect constant, dans
lequel seules les surfaces critiques correspondant aux apparition/disparition d’objets sont encod ées.
En pratique, des partitions approchées sont utilisées à défaut dans le domaine du calcul de <PVS>.
Ce sont ces techniques que nous étudions dans la section suivante.
3.3.1 Partitions utilisées pour encoder les <PVS>

Avec la technique du <PVS>, l’ensemble des objets visibles depuis le point P est assimilé à
l’ensemble des objets visibles depuis la cellule qui contient ce point. Cette approximation est exacte
si la cellule est incluse dans une des cellules de la partition en cellules de visibilité constante. Si au
contraire la cellule est traversée par des surfaces critiques, la cellule n’est plus homogène du point de
vue de la visibilité. Dans ce cas, l’ensemble des primitives visibles depuis la cellule est supérieur à
l’ensemble des primitives visibles depuis le point P ; cela signifie que l’ensemble des primitives est
surestimé par rapport à la visibilité exacte : on introduit un facteur de sur-conservativité, que nous
avons appelé ci-dessus la sur-conservativité due à la partition.
Pour réduire la sur-conservativité due à la partition, il est donc souhaitable que la partition utilisée
soit aussi proche que possible de la partition théorique en cellules de visibilité constante ; mais un
compromis doit être effectué car le nombre de cellules doit rester réduit :
– il influence directement le temps de calcul et le coût de stockage du PVS ; cette contrainte
est d’autant plus critique que l’environnement est large et que l’utilisateur a la possibilité de
naviguer dans tout l’espace 3D.
– la partition doit être simple pour permettre une localisation simple de la caméra, puisqu’elle
doit être réalisée à chaque image.
Cohen et al. utilisent les cases d’une grille régulière comme cellules de PVS [44] (cf. Figure 3.19).
La résolution de la grille doit être choisie suffisamment fine pour réduire la sur-conservativité, mais
ne peut pas être trop élevée étant donné que le coût de la partition augmente rapidement avec la
résolution. Cette approche n’est pas très efficace, car tout l’espace navigable ne nécessite pas une
grille de résolution identique, et un encodage hiérarchique serait souvent plus intéressant (cf. Fi-
gure 3.19(c)).
(a) (b) (c)
F IG . 3.19: Différents types de partition. (a) Partition en cellules de visibilit é constante (non utilisée en pratique).
(b) Partition régulière [44]. (c) Partition non régulière, obtenue soit par fusion de cellules dont les PVS sont
similaires [139, 57, 157, 96], soit par subdivisions successives [138, 57, 119].
Pour en obtenir un, Schauffler et al. et Durand et al. partent d’une grille fine, et fusionnent les
cellules dont les PVS sont similaires [139, 57]. Cette approche a été généralisée par Van de Panne et
al. [157], qui subdivisent non seulement l’espace navigable, mais également la géométrie de la scène.
Partant d’un découpage très fin pour la géométrie comme pour l’espace navigable, le PVS de chacune
des cellules est calculé dans une première phase. Ensuite, les cellules dont les PVS sont similaires
sont fusionnées, alors que les objets vus par les mêmes cellules sont également fusionnés pour ob-
tenir des objets de plus grande taille. Avec ce procédé, la segmentation de la scène en objets et la
partition de l’espace navigable en cellules ont un sens du point de vue de la visibilité. L’objectif de
ces méthodes est de réduire l’information à stocker, mais elles ne réduisent pas le temps de calcul
puisque les calculs de visibilité sont effectués à la résolution la plus fine. Récemment, Samuli Laine
a montré qu’il était possible de réduire ce temps de calcul en partageant l’information déjà calculée
entre cellules voisines [96]. Sa technique consiste à définir un ordre de parcours des cellules, puis à
calculer le PVS des cellules de manière incrémentale : une approximation conservative du PVS d’une
cellule est déduite du PVS des cellules voisines déjà traitées ; le PVS de la cellule est ensuite calculé à
partir de cette première approximation. Samuli Laine montre que cette approche permet d’obtenir un
résultat proportionnel au résultat en sortie, c’est-à-dire au nombre d’objets visibles.
Pour éviter le calcul initial à pleine résolution d’un PVS de la scène, des approches par subdivisions
ont également été proposées : partant d’une partition grossière, les cellules sont subdivisées afin d’ap-
procher la partition en cellules de visibilité constante, la solution initiale étant raffinée aux endroits
propices [138, 57, 119]. Ce schéma de subdivision a une propriété intéressante : chaque cellule est ob-
tenue en subdivisant une cellule <mère> de plus grande taille, ce qui signifie que son PVS est inclus
dans celui de la cellule mère initiale. Cette propriété peut être mise à profit pour effectuer un calcul de
visibilité incrémental : seuls les objets visibles depuis la cellule mère doivent être testés lors du calcul
du PVS d’une nouvelle cellule. Les calculs deviennent de moins en moins coûteux au fur et à mesure
que les cellules sont subdivisées et que la sur-conservativité de la partition diminue [119] (le PVS des
cellules tend vers un PVS ponctuel).
Certaines techniques ne créent pas explicitement de partition de l’espace navigable, mais main-
tiennent dynamiquement le PVS d’une cellule se déplaçant avec la caméra. Coorg et al. maintiennent
dynamiquement la cellule d’un graphe d’aspect linéarisé et simplifié [40] (cf. section 2.1.4). Wonka
et al. utilisent comme cellule de visibilité une sphère se déplaçant avec la caméra, la visibilité depuis
la sphère étant calculée ponctuellement depuis son centre, après <réduction> des écrans [166] (cf.
section 3.2.1.4).
Il est également possible d’exploiter les propriétés particulières d’une scène pour placer les cel-
lules, par exemple en utilisant les pièces d’un bâtiment dans une scène architecturale [156, 107] ou les
rues dans une scène de ville [139].
3.4 Stockage de <PVS>

Par définition, le <PVS> d’une cellule est la liste des objets visibles depuis la cellule. Le mot
<PVS> seul est utilisé pour désigner l’ensemble des PVS de toutes les cellules de la partition. L’enco-
dage naı̈f consiste à stocker explicitement le <PVS>, sous la forme d’une liste associée à chaque cel-
lule. Pour une cellule considérée individuellement, cette approche est sensible à la taille des données
en sortie. Malheureusement, elle est proportionnelle au nombre de cellules, et peut devenir prohi-
bitive avec un grand nombre de cellules. Différentes approches ont été proposées pour compresser
cette information. Durand et al. utilisent une technique de compression différentielle, en encodant
les différences existant entre PVS de cellules voisines [57]. Nadler et al. utilisent également une ap-
proche différentielle : les cellules sont subdivisées de manière hiérarchique, et ce sont les différences
de PVS survenant lors des subdivisions qui sont encodées [115]. Gotsmann et al. utilisent un encodage
hiérarchique dans le contexte du calcul de PVS par subdivision de faisceaux (cf. section3.2.1.6) : la
hiérarchie est la subdivision hiérarchique d’un faisceau en sous-faisceaux [73].
Van de Panne et al. représentent l’information de visibilité dans une table binaire, dont les lignes sont
les cellules et dont les colonnes sont les objets. La case de coordonnées (i; j) de cette table contient
un 1 si l’objet j est visible depuis la cellule i, et un 0 dans le cas contraire [157]. Cette table est com-
pressée, avec une combinaison de deux algorithmes de compression, le premier étant sans perte et le
second avec perte. Les auteurs montrent que cette approche regroupe les cellules dont la visibilité est
similaire et fusionne les objets vus depuis les mêmes ensembles de cellules (cf. section3.3). Zach et
al. exploitent la même idée, mais inversent les lignes et les colonnes de la table pour augmenter le taux
de compression [170]. Dans le même but, Chhugani et al. réordonnent les objets de la scène avant de
compresser la table à l’aide d’un algorithme de <run-length encoding> [29].
Kotlun et al. abandonnent le stockage explicite des <PVS>, et encodent à la place des <écrans vir-
tuels> permettant de reconstruire le PVS durant la phase de navigation interactive [94, 13]. Les écrans
virtuels sont des polygones n’appartenant pas à la scène qui permettent d’encoder l’ombre générée par
la région remplacée par une lampe étendue. Bernardini et al. proposent une technique similaire : ils
utilisent comme écrans virtuels les faces des boı̂tes englobantes entourant les nœuds d’une hiérarchie
contenant la scène [13]. Grâce aux écrans virtuels, l’information stockée est indépendante de la taille
de la scène, et ne dépend plus que de la complexité locale de la visibilité autour de la cellule [86].
Cette idée a été exploitée par toutes les techniques utilisant des écrans virtuels [86, 26, 50, 146, 105]
(cf. section 3.2.1.5).
3.5 Discussion
L’utilisation d’un <PVS> ne permet pas d’encoder la visibilité de manière exacte, puisque l’en-
semble des objets visibles depuis un point est approché par l’ensemble des objets visibles depuis la
région qui le contient. Il en résulte un affichage superflu d’objets, mesuré par la sur-conservativité due
à la partition. Pour le réduire, il est nécessaire de créer une partition qui soit la plus proche possible de
la partition en cellules de visibilité constante. Mais comparativement au calcul de la visibilité depuis
une région, le problème complémentaire du placement des cellules a été très peu étudié [35], et les
solutions existantes sont relativement naı̈ves.
En ce qui concerne le calcul de visibilité depuis une région, sa résolution exacte, nécessitant la
fusion complète des écrans, a longtemps été considérée comme impraticable [47, 120] et à défaut,
des techniques approchées furent utilisées [38]. Ces dernières simplifient le problème, et de nom-
breuses occultations ne sont pas détectées. Il en résulte également l’affichage d’objets superflus,
qui se mesure par la sur-conservativité due à la méthode. Seules les techniques exactes permettent
de considérer toutes les occultations et permettent d’éliminer ce facteur de sur-conservativité. Les
premières méthodes exactes sont apparues récemment [120, 20], mais leur difficulté de mise en œuvre
et leur coût élevé en temps de calcul en a limité la diffusion.
La complexité d’un calcul de <PVS> est très dépendante des données. Outre le fait que certains
algorithmes ne sont utilisables que pour certains types de scènes (scènes 2D12 , scènes d’intérieur,
etc.) [18], la configuration géométrique des objets influence beaucoup le temps de calcul. Dans une
scène où il existe beaucoup d’occultations, les ombres fusionnent très rapidement et génèrent de
larges volumes d’ombre, contenant la majorité de la scène. L’utilisation d’une structure de données
hiérarchique pour regrouper les objets permettra de détecter des ensembles d’objets appartenant à ces
larges zones d’ombre à l’aide d’une seule opération. De plus, même des modèles très simples, cap-
turant l’ombre de manière très approximative, permettront tout de même de capturer les ombres de
manière satisfaisante. Au contraire, lorsque les écrans sont dispersés, les occultations ne se combinent
plus, et les ombres sont réduites ; dès lors, il faudra considérer chaque objet individuellement pour
déterminer s’il est masqué et il sera nécessaire d’approcher les ombres de manière très précise pour
espérer capturer l’occultation existant dans la scène. Il en est de même pour la partition de l’espace
navigable en cellules : elle est beaucoup plus critique dans les scènes d’extérieur très ouvertes, où
l’espace navigable est étendu, que dans les scènes d’intérieur dans lesquelles l’espace navigable est
réduit et la position géométrique des cellules est plus simple à définir (par exemple les pièces d’un
bâtiment). Différentes méthodes ont été proposées pour tenter de quantifier ces phénomènes et mesu-
rer la complexité d’une scène en fonction de la visibilité [129, 60, 61, 75, 117, 59].
4 Encodage de la visibilité sous la forme de graphes cellules-portails

4.1 Introduction
Certaines méthodes d’<occlusion culling> tirent parti des caractéristiques particulières de la scène
pour calculer les objets masqués depuis tout point de l’espace navigable. Citons par exemple les
travaux de Wonka et al. pour les scènes de villes [165] ou ceux de Stewart pour les scènes de ter-
rains [145]. En pratique, les scènes architecturales constituent une classe de scènes très importante.
Du point de vue de l’occultation, ces dernières possèdent des propriétés intéressantes [154] :
– L’essentiel de la géométrie est caché par les murs ; une bonne approximation consiste à considérer
que seuls ces derniers jouent le rôle d’écran pour la détermination de la visibilité.
– Une grande partie du modèle n’est pas visible lorsque la caméra est placée à l’intérieur d’une
pièce d’un bâtiment. De plus, les surfaces situées à l’extérieur de la pièce ne sont visibles qu’à
travers des portes et des fenêtres.
Les graphes cellules-portails exploitent ces propriétés [88, 156, 3, 107, 87, 106, 100]. Le bâtiment
est décomposé en cellules (tout comme dans les méthodes de précalcul de PVS), qui correspondent
approximativement aux différentes pièces. Les ouvertures (les portes et les fenêtres) sont repérées
à l’aide de portails 27 , qui sont des contours polygonaux. L’information est stockée sous la forme
d’un graphe, que nous appelons graphe <CPG> 28 , dont les nœuds sont les cellules et dont les arcs
sont les portails, qui connectent des cellules voisines géométriquement. Un exemple est donné à la
Figure 3.20.
(a) (b)
F IG . 3.20: Méthodes cellules-portails (a) Sc ène architecturale 2D. Les cellules sont color ées et indiquées par
des lettres majuscules ; les portails sont numérotés et dessinés en rouge. (b) Le graphe cellules-portails corres-
pondant.
Grâce à cette structure de données, il est possible d’éliminer rapidement la géométrie occultée par
les murs, en n’affichant que les surfaces visibles à travers des ouvertures [156, 153, 155, 107, 87, 106].
La première étape consiste à localiser l’observateur dans une des cellules du graphe. Ensuite, le graphe
est traversé à l’aide d’un parcours en profondeur ((cf. Cormen et al. page 525 [41])), et un cône de vue
est calculé, qui représente la zone visible depuis l’observateur. Ce cône est rétréci chaque fois qu’un
portail est traversé (cf. Figure 3.21).
27 Les <portails> sont appelés <hublots> par certains auteurs [54, 47].
28 Graphe <CPG> pour <Cell-and-Portal Graph> en anglais.
4 Encodage de la visibilité sous la forme de graphes cellules-portails 61
F IG . 3.21: Elimination d’une scène avec un graphe <CPG>. L’observateur est en D. Le c ône de vue est adapté
lorsqu’un portail est traversé. Les objets visibles sont situés à l’intérieur du cône de vue.
Remarque : Dans une scène architecturale, seule l’occultation générée par les murs est capturée par
un graphe cellules-portails. Les autres objets sont considérés comme du <détail>, et l’on considère
qu’ils ne masquent pas suffisamment d’objets pour que l’on en tienne compte [154].
Les graphes cellules-portails sont souvent créés à la main, à l’aide d’outils de modélisation [88,
107] : la tâche consiste à repérer chaque ouverture à l’aide d’un portail, et à segmenter la géométrie de
la scène en cellules. Des algorithmes de création automatique de graphes <CPG> ont également été
proposés, et font l’objet de la section 4.2. Les méthodes permettant de déterminer les objets masqués
à l’aide d’un graphe <CPG> sont présentées dans la section 4.3.
4.2 Génération automatique de graphes cellules-portails

La première catégorie d’algorithmes de création est basée sur l’utilisation d’arbres <BSP>29, qui
sont eux-mêmes des décompositions en cellules-portails [3, 156, 111, 99]. L’essentiel de ces algo-
rithmes réside dans le choix du plan de découpe associé à chaque nœud du graphe <BSP>. Les pre-
miers algorithmes nécessitaient des modèles dont la géométrie est alignée avec les axes [3, 156]. Pour
les scènes semi-axiales 30 , Meneveaux et al. proposent de choisir la position des plans de découpe
dans un espace dual [111] : chaque mur vertical est transformé en un point dans l’espace dual, et
une procédure de <clustering> y est utilisée pour regrouper les points similaires. Le centre de gra-
vité de chacun des groupes fournit le plan de découpe recherché. Différentes contraintes sont ensuite
utilisées pour obtenir les cellules. Lei et al. proposent une autre technique, basée sur un processus
de modélisation de la scène de type <CSG>31, qui permet ensuite de générer facilement les graphes
cellules-portails [100]. Dans les scènes 3D, Lefebvre et al. notent que les arbres <BSP> sont souvent
sur-segmentés, et qu’ils contiennent plus de cellules et de portails que nécessaire. Ils proposent donc
de simplifier les arbres <BSP>, en éliminant les portails inutiles et en fusionnant les cellules voisines
pour obtenir un graphe <CPG> mieux adapté [99].
29 <Arbre BSP> pour <Binary Space Partitionning> en anglais. Les arbres <BSP> sont des arbres binaires dont chacun
des nœuds stocke l’équation d’un hyperplan qui sépare l’espace en deux demi-espaces ouverts.
30 Une scène semi-axiale est une scène dont les murs sont verticaux.
31 <CSG> pour <Constructive Solid Geometry> en anglais. La <CSG> consiste à réaliser des opérations de théories des
ensembles (addition, soustraction, intersection, union) entre des primitives simples (cubes, sphères, polyèdres,...) afin de
modéliser des objets plus complexes.
Les portails obtenus par les méthodes basées sur un arbre <BSP> sont alignés avec les éléments
géométriques de la scène, ce qui réduit la méthode à des ensembles de géométrie restreints. De plus,
ces approches sont limitées aux ensembles de données contenant des plans, et donnent des graphes
inutilisables lorsque le nombre de polygones augmente, car chaque polygone crée un plan de découpe
et ajoute des portails à la décomposition. C’est pourquoi d’autres techniques sont nécessaires lorsque
la scène ne répond pas à ces contraintes.
Dans le contexte particulier de la colonoscopie virtuelle [85], Lichan et al. exploitent la structure tu-
bulaire de la scène pour créer les graphes <CPG> 32 . Leur algorithme consiste à calculer un champ
de distances à la géométrie, puis à extraire le squelette de ce champ de distances 33 , qui fournit une
ligne centrale traversant la géométrie. La scène est ensuite découpée en cellules de manière régulière,
en plaçant des portails perpendiculairement au squelette.
Lerner et al. étendent les graphes <CPG> aux scènes 2D12 pour traiter le cas des villes [101]. L’algo-
rithme crée la partition en 2D, à partir de l’empreinte des bâtiments sur le sol, qui sont des polygones.
Au cours d’une première phase, les arêtes de ces polygones sont parcourues de proche en proche, dans
le sens des aiguilles d’une montre, en choisissant toujours localement le chemin le plus court. Lorsque
ce chemin implique de passer à un autre bâtiment, un portail est généré. Cette procédure décrit des
boucles, chacune entourant un espace qui est identifié à une cellule. La seconde phase utilise une heu-
ristique pour améliorer le graphe obtenu dans la première étape. Les auteurs proposent également une
mesure permettant d’évaluer l’efficacité du graphe généré [101].
4.3 Détermination des objets masqués à partir d’un graphe cellules-portails

Lorsque l’on utilise un graphe cellules-portails, le problème de visibilité consiste à déterminer
l’ensemble des objets visibles au travers d’une séquence de portails. Les graphes <CPG> ont été in-
troduits initialement par Jones et al. pour le calcul des faces cachées depuis un point [88]. La première
étape de leur algorithme consiste à localiser le point dans la partition en cellules. Ensuite, le graphe
<CPG> est traversé à l’aide d’un parcours en profondeur. Chaque portail rencontré est projeté dans
l’image que l’on est en train de calculer sous forme de masque, de sorte que les portails se super-
posent dans l’image au fur et à mesure du parcours du graphe. L’intersection de toutes les zones non
masquées indique les zones visibles. Le parcours s’arrête lorsque l’intersection est vide, car la vue est
alors entièrement <bouchée>. Luebke et al. ont adapté cet algorithme pour l’<occlusion culling> :
après leur projection dans l’image, chaque portail est approché de manière conservative par un rec-
tangle englobant 2D : les intersections sont plus simples et plus rapides à calculer [107]. Récemment,
Lowe et al. ont proposé un algorithme combinant différentes fonctionnalités modernes des cartes gra-
phiques pour calculer dans l’espace image la visibilité au travers de séquences de portails complexes
polygonaux quelconques (c-à-d non-convexes et non-plans) [106].
Airey et al. ne calculent pas la visibilité en ligne, mais déterminent au cours d’une phase de
précalcul le PVS de chaque cellule du graphe [3]. Il s’agit donc d’une technique de précalcul de PVS,
semblable à celles présentées dans la section 3, la différence étant que le graphe cellules-portails est
utilisé comme structure de données intermédiaire pour effectuer les calculs de PVS. Airey et al. uti-
lisent un algorithme d’échantillonnage pour déterminer les objets visibles depuis chaque cellule : des
rayons aléatoires sont lancés au travers de chaque séquence de portails, afin de déterminer les objets
visibles [3]. Il s’agit donc d’une technique agressive, qui génère potentiellement des erreurs lors de
l’affichage.
32 La scène considérée est le colon humain.

33 Le terme <squelette> est utilisé ici au sens de l’analyse morphologique d’images [72].
4 Encodage de la visibilité sous la forme de graphes cellules-portails 63
Les premiers algorithmes de précalcul exacts et conservatifs à partir de graphe <CPG> furent
proposés par Teller et al. [156, 154, 152, 155]. En 2D, et dans des scènes alignées avec les axes, Teller
et al. ramènent le problème du calcul des objets visibles au travers d’une séquence de portails à un
problème de programmation linéaire [156]. En 3D, ils le ramènent à un problème du poignardage de
polygones [152] (cf. page 27). Chaque face S de la cellule, supposée convexe, est considérée tour à
tour. La visibilité d’une primitive R, depuis la face S d’une cellule, est déterminée en testant s’il existe
au moins un rayon quittant la face S qui atteint l’objet R après son passage à travers la séquence de por-
tails les séparant. Les auteurs expriment le problème dans l’espace de Plücker : les arêtes des portails
et des objets S et R sont transformées en hyperplans ; l’objet sera visible si le système d’inéquations
formé par ces hyperplans possède une solution, et si l’intersection de cette solution avec la quadrique
de Plücker n’est pas vide. Ce calcul est réalisé à l’aide d’un algorithme de calcul d’enveloppe convexe.
Dans un travail antérieur, Seth a utilisé une technique semblable pour calculer précisément les limites
d’ombre et de pénombre générées par une lampe étendue [153]. Pour ce faire, il calcule explicitement
l’équation des surfaces critiques, en résolvant le système d’équations décrit ci-dessus. Teller et al.
ont également proposé des algorithmes permettant d’évaluer de manière conservative la visibilité au
travers d’une séquence de portails [155, 154]. Seules les surfaces critiques planes sont considérées,
et les surfaces critiques de degré 2 sont ignorées 34 . Cet algorithme est conservatif, car le volume de
visibilité calculé englobe le volume de visibilité exact. Jimenez et al. étendent cette technique, et pro-
posent un squelette de visibilité adapté pour calculer la visibilité au travers d’une séquence de portails
de manière incrémentale [87].
Finalement, dans le contexte du calcul exact de visibilité dans les scènes de villes 2D12 , Bittner
et al. utilisent des portails générés à la demande, pour représenter la visibilité dans le plan vertical :
des portails sont érigés au-dessus de chaque bâtiment, et utilisés pour calculer une approximation
conservative de la visibilité avant l’utilisation d’un calcul de visibilité exact [19].
4.4 Discussion
Les graphes cellules-portails sont très répandus, notamment dans l’industrie du jeu vidéo [16],
car ce sont des méthodes qui permettent d’éliminer de manière simple et robuste une grande partie
des objets masqués. De plus, les besoins en mémoire de cette méthode sont réduits, ce qui la rend
attractive dans tous les domaines d’application pour lesquels la mémoire disponible est limitée.
Aujourd’hui, l’utilisation des graphes <CPG> pour l’<occlusion culling> semble être arrivée à
maturité, et des algorithmes efficaces existent [107, 106]. Mais la création du graphe en lui-même est
encore problématique car il n’existe pas de solution générale satisfaisante qui soit opérationnelle dans
tous les cas de figure, et faute de techniques automatiques adéquates, les graphes <CPG> sont encore
souvent générés à la main.
34 Ces surfaces critiques sont générées par les ensembles de trois arêtes gauches.
R e q u ê t e e x a c t e d ’ o c c u l t a t i o n
chapitre 4
entre deux polygones
Sommaire
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
1.1 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
1.2 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.1 Principes généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.2 Ensemble des droites poignardant deux polygones . . . . . . . . . . . . . 69
2.3 Découpe de polyèdres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
2.4 Calcul exact de visibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3 Algorithmes basés sur le 1-squelette des polytopes dans l’espace de Plücker . . 71
3.1 Algorithme de découpe de polytopes à d dimensions . . . . . . . . . . . . 71
3.2 Construction de l’ensemble des droites poignardant deux polygones 3D . . 73
3.3 Complexité théorique des algorithmes . . . . . . . . . . . . . . . . . . . . 76
4 Requête simple et efficace d’occultation entre deux polygones . . . . . . . . . . 78
4.1 Sélection des écrans guidée par la visibilité . . . . . . . . . . . . . . . . . 78
4.2 Agrégation des écrans basée sur leur silhouette étendue . . . . . . . . . . . 79
4.3 Algorithme pour une requête d’occultation analytique entre deux polygones 82
4.4 Analyse de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.5 Relation entre l’algorithme de soustraction et la visibilité analytique . . . . 84
5 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.1 Evaluation des performances de l’algorithme . . . . . . . . . . . . . . . . 88
5.2 Sélection des écrans et détection des ouvertures . . . . . . . . . . . . . . . 92
6 Conclusion et perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
1 Introduction
Comme nous l’avons vu dans l’état de l’art, le modèle du <PVS> précalculé nécessite d’une
part un algorithme afin de découper l’espace navigable en cellules, et d’autre part un algorithme de
calcul de visibilité depuis une région permettant de déterminer le <PVS> de chacune des cellules,
c’est-à-dire la liste des primitives visibles depuis au moins un point de la cellule. Les algorithmes de
66 chapitre 4. Requête exacte d’occultation entre deux polygones
calcul de visibilité depuis une région sont classés en différentes catégories suivant le résultat qu’ils
produisent (cf. page 46). Ce chapitre est consacré aux algorithmes exacts, qui déterminent le <PVS>
de manière analytique [131, 95, 24, 120, 20, 113, 19] : en réalisant la fusion complète des écrans, ils
éliminent entièrement la sur-conservativité due à la méthode. Pour un ensemble donné de cellules,
les performances obtenues lors de l’exploration interactive sont donc optimales, puisque les seules
primitives qui seront affichées sont celles qui sont effectivement visibles depuis au moins un point de
la cellule dans laquelle se trouve l’utilisateur.
Les algorithmes exacts tirent parti du fait que le <PVS> d’une région volumique est égal à l’union des
<PVS> de chacune des faces de la région (cf. page 54). De la sorte, le calcul de <PVS> se ramène
au calcul de visibilité depuis une surface. Ce dernier peut être résolu en exprimant le problème dans
l’espace dual de Plücker : les ensembles de droites y sont représentés par des polyèdres (cf. page24),
et les relations d’occultation sont maintenues sous la forme de complexes de polyèdres1 .
Malheureusement, les méthodes existantes sont difficiles à mettre en œuvre, coûteuses en temps
de calcul, et peu robustes, ce qui les rend inadaptées à une utilisation pratique et freine leur diffusion.
Dans ce chapitre, nous proposons des améliorations de cet état de fait. Notre point de départ a été le
travail de Nirenstein et al. [120], auquel nous avons apporté différentes améliorations. Le résultat est
un algorithme de calcul exact de visibilité depuis une région, qui est plus simple à mettre en œuvre,
plus rapide et plus robuste que les algorithmes existant dans la littérature.
1.1 Contributions
Algorithmes basés sur le squelette des polytopes dans l’espace de Plücker : Le maintien de
l’occultation à l’aide d’un complexe de polytopes dans l’espace de Plücker nécessite deux opérations
fondamentales : la création d’un polytope 2 représentant l’ensemble des droites poignardant deux
polygones, et un algorithme de découpe de polytopes pour effectuer les opérations de <CSG>. Nous
présentons de nouveaux algorithmes pour réaliser chacune de ces opérations, chacun d’entre eux n’uti-
lisant que le 1-squelette des polytopes (les sommets et les arêtes des polytopes) à la place du graphe
d’incidence utilisé précédemment [120].
Requête d’occultation efficace entre deux polygones : Les algorithmes basés sur le 1-squelette
des polytopes sont des briques de base, utilisables par tout algorithme exact de visibilité depuis une
région : nous montrons comment les utiliser dans le contexte de requêtes d’occultation exactes entre
deux polygones convexes. De plus, nous combinons de nouvelles techniques pour augmenter leur
efficacité :
– nous proposons de lancer des rayons dans les ouvertures laissées par les écrans déjà traités. Par
construction, la méthode détecte rapidement les ouvertures qui existent entre les polygones, et
autorise un arrêt précoce de la requête dans le cas de la visibilité mutuelle. Les rayons sont
également utilisés pour la sélection des écrans, afin d’être certain que chacun des écrans utilisés
bloquera une partie de l’espace des droites qui n’a pas encore été traité.
– nous proposons un nouveau mécanisme de fusion des écrans, spécialement adapté aux requêtes
de visibilité exprimées dans l’espace de Plücker. En éliminant les arêtes des écrans qui ne
font pas partie de la silhouette étendue des écrans composés de polygones connectés3 , nous
montrons qu’une grande partie des calculs redondants peuvent être éliminés.
1 Dans ce chapitre, nous appelons complexe C un ensemble de polyèdres convexes Pi .
2 Comme nous l’avons expliqué page 20, un polytope est un polyèdre borné.
3 La silhouette étendue est la <from-region silhouette> en anglais.
Remarque : Ces travaux ont fait l’objet d’une publication au symposium <Eurographics Symposium
on Rendering> en 2005, sous le tire <A Low Dimensional Framework for Exact Polygone-to-Polygon
Occlusion Queries> [82]. Ils ont été réalisés en collaboration avec Otso Mäkinen et Shaun Nirenstein.
1.2 Plan du chapitre

Dans la section 2, nous présentons un état de l’art concernant les méthodes exactes de calcul de
visibilité depuis une région, après avoir introduit les principes généraux communs à ces techniques.
Nous présentons ensuite dans la section 3 deux algorithmes originaux, permettant de maintenir l’oc-
cultation dans l’espace de Plücker . La section 4 est consacrée à la description d’une requête d’oc-
cultation entre deux polygones exploitant ces algorithmes. Les résultats obtenus sont présentés dans
la section 5. Finalement, les conclusions et les perspectives d’amélioration sont présentées dans la
section 6.
2 Etat de l’art
Dans cette section, nous décrivons les méthodes exactes utilisées dans le domaine de l’<occlusion
culling>, permettant de déterminer l’ensemble des primitives polygonales de la scène qui sont visibles
depuis un polygone S au travers d’un ensemble d’écrans polygonaux Oi . Le polygone S est supposé
convexe 4 et les écrans Oi sont des maillages polygonaux.
2.1 Principes généraux

Soit R un polygone de la scène dont on souhaite déterminer la visibilité depuis S, c’est-à-dire
déterminer s’il existe au moins un point de S depuis lequel R est visible. Pour ce faire, les méthodes
analytiques représentent l’ensemble des droites poignardant simultanément S et R à l’aide d’un polyèdre
dans l’espace dual des droites (cf. Figure 4.1). L’ensemble des droites qui traversent simultanément S
et R est le polyèdre P (S; R). Chaque écran intercepte un ensemble de droites qui peut également être
représenté à l’aide d’un polyèdre Oi (S; R).
– Le polyèdre convexe P \ Oi contient l’ensemble des droites qui poignardent S et R, et qui sont
bloquées par Oi .
– Le polyèdre non-convexe P Oi contient l’ensemble des droites qui poignardent S et R, et qui
ne sont pas bloquées par Oi . Pour éviter de devoir travailler avec un polyèdre non-convexe, ce
polyèdre est habituellement décomposé en un complexe de polyèdres convexes.
L’ensemble des droites qui ne sont pas bloquées par un ensemble de n écrans convexes Oi est
calculé en soustrayant successivement de P les n polyèdres Oi correspondant à chacun des écrans,
au moyen d’opérations de <CSG> dans l’espace dual. Le résultat est maintenu sous la forme du
complexe de polyèdres C , représentant l’ensemble des droites qui n’ont pas encore été bloquées par
les écrans qui ont déjà été traités. L’opération de soustraction en elle-même est effectuée en découpant
le polyèdre P avec les hyperplans de Oi , tandis que la partie de P qui est située à l’intérieur du
polyèdre Oi est éliminée. Si le polyèdre P est entièrement éliminé par la soustraction d’un ensemble
de polyèdres Oi , cela signifie que R est masqué par l’ensemble des écrans Oi . Dans le cas contraire,
des droites non bloquées existent et R est visible depuis S (cf. Figure4.2).
4 Si S n’est pas convexe, il est décomposé en polygones convexes S , et un calcul de visibilité est effectué pour chacun
i
d’entre eux. La visibilité depuis le polygone S est égale à l’union de la visibilité depuis les polygones Si .
F IG . 4.1: (a) Le polyèdre P , représentant dans l’espace primal l’ensemble des droites poignardant simul-
tanément les polygones S et R. (b) L’ écran Oi bloque un ensemble de droites. (c) Le complexe C = fP 1 ; P2 g
contenant le résultat de l’opération P Oi . Dans l’espace primal 3D, il représente un ensemble de droites qui
ne sont bloquées par aucun écran Oi
F IG . 4.2: Lorsque tous les écrans ont été traités, le complexe résultant représente l’ensemble des droites qui
n’ont pas été bloquées.
En 2D, l’espace dual est également bi-dimensionnel, et des algorithmes efficaces existent [95,24].
Comme montré récemment par Bittner et al. [19], ces algorithmes peuvent être étendus au cas 2D12 .
En 3D, l’espace dual est l’espace projectif 5D de Plücker. La transformation du problème vers cet es-
pace est obtenue en utilisant l’équation (2.11) (du chapitre 3), afin de transformer les droites contenant
les côtés des polygones de la scène en hyperplans dans l’espace de Plücker (cf. Figure4.3).
Il est possible de démontrer que l’ensemble des droites poignardant un polygone est représenté par
un polyèdre (une région convexe non bornée de l’espace), et que l’ensemble des droites poignardant
deux polygones peut être représenté par un polytope (un polyèdre borné) [118] 5 . Dans les deux cas,
l’ensemble des droites poignardantes est représenté par la portion de la quadrique de Plücker qui est
délimitée par le polyèdre. En particulier, le point dual B de la droite poignardante b est situé sur la
quadrique de Plücker, et à l’intérieur du polyèdre. Les points d’intersection S des côtés du polyèdre
avec la quadrique de Plücker sont les droites poignardantes extrêmes des polygones [153]. En 3D,
chaque droite poignardante extrême s est incidente à quatre côtés (voire plus dans les configurations
dégénérées) (cf. Figure 4.3).
Le maintien de l’occultation à l’aide d’un complexe de polyèdres dans l’espace de Plücker nécessite
deux opérations fondamentales : la création d’un polyèdre représentant l’ensemble des droites poi-
gnardant deux polygones, et un algorithme de découpe de polyèdres pour effectuer les opérations de
5 Les côtés des polygones doivent être orientés de manière consistante, de telle sorte que toute droite poignardante b les
franchisse avec la même orientation relative.

F IG . 4.3: Correspondance entre l’espace primal 3D et l’espace dual de Pl ücker (Ce schéma de principe est
une évocation de la réalité, car l’espace de Pl ücker est en réalité un espace projectif orienté 5D P5o ). Les côtés
initiaux des polygones sont transform és en hyperplans dans l’espace dual de Pl ücker. Les droites incidentes à
quatre côtés sont les droites poignardantes extrêmes s. Les courbes sur la quadrique de Pl ücker sont les traces
des 2-faces du polyèdre (c-à-d. les faces de dimension 2), et correspondent à des droites incidentes à 3 arêtes
de S et R.
<CSG>, que nous présentons dans les sections 2.2 et 2.3. Nous présentons ensuite dans la section 2.4
les algorithmes de calcul de visibilité depuis une surface, qui ont été proposés dans la littérature et qui
utilisent ces deux opérations fondamentales.
2.2 Ensemble des droites poignardant deux polygones

Soit deux polygones convexes S et R définis dans R3 . Nous allons étudier le problème de la
construction du 1-squelette d’un polyèdre P , défini dans l’espace de Plücker, dont l’intersection avec
la quadrique de Plücker représente l’ensemble des droites poignardant S et R.
Dans la littérature, ce problème a d’abord été résolu à l’aide d’un algorithme d’énumération de
sommets [120, 20] :
– les arêtes de chacun des polygones S et R sont transformées en hyperplans dans l’espace de
Plücker. Ces hyperplans délimitent le polyèdre P recherché.
– un algorithme d’énumération de sommets [10] est utilisé pour construire le 1-squelette à partir
de l’équation des hyperplans6 .
Cette approche est la plus générale possible, et est beaucoup plus lente qu’une approche dédicacée,
étant donné qu’elle ne tient pas compte des spécificités du problème. De plus, cette approche est
très sensible aux imprécisions numériques, et ne produit pas toujours une solution correcte dans des
configurations particulières. C’est pourquoi Shaun Nirenstein a proposé un algorithme direct pour
construire le polyèdre P [118]. Il démontre tout d’abord que le polyèdre P peut être transformé en un
prisme lorsqu’il est projeté sur un hyperplan de projection particulier. Il introduit ensuite l’idée d’utili-
ser deux hyperplans de découpe, placés perpendiculairement à l’axe vertical du prisme, pour borner le
polyèdre P . La position de ces plans est fixée par le choix des termes indépendants. Le choix proposé
est très conservatif, afin de s’assurer qu’aucune droite poignardante n’est éliminée.
6 La représentation d’un polyèdre à partir de l’équation de ses hyperplans est appelée sa <H-représentation>. La
représentation du polyèdre avec son 1-squelette est appelée sa <V-représentation>. Le passage de la H-représentation à
la V-représentation est le problème classique de l’énumération de sommets. Ce problème est le dual du problème du pas-
sage de la V-représentation vers la H-représentation : ce problème n’est autre que le problème classique en géométrie
algorithmique du calcul d’enveloppe convexe.
Bien que cet algorithme de construction ait également été utilisé par Mora et al. [113], à notre connais-
sance aucune implémentation n’en a été évaluée.
2.3 Découpe de polyèdres

Les opérations de découpe sont effectuées à l’aide de l’algorithme d’énumération de sommets dans
la thèse de Jiřı́ Bittner [20] : les deux polyèdres qui résultent de la découpe sont obtenus en ajoutant
l’équation de l’hyperplan de découpe à la liste des facettes du polyèdre initial. Dans l’article [120],
Nirenstein et al. proposent un algorithme de découpe plus efficace, utilisant la méthode proposée par
Bajaj et al. [11], basée sur le graphe d’incidence du polyèdre [65]. Cette méthode nécessite que le
polyèdre soit borné. Après la construction du 1-squelette du polyèdre, le graphe d’incidence complet
est reconstruit à partir d’un algorithme d’énumération de facettes [65]. Ensuite, l’opération de découpe
basée sur ce graphe consiste à parcourir toutes les k-faces du polyèdre dans toutes les dimensions, en
commençant par les faces de dimension 1, et en terminant avec les faces de dimension d. La découpe
proprement dite est effectuée en réalisant des opérations de calcul sur le graphe d’incidence. Cet
algorithme a aussi été utilisé par Mora et al. [113]. Nous renvoyons à la thèse de Shaun Nirenstein
pour une description précise de cet algorithme [118].
2.4 Calcul exact de visibilité

En 2D, Koltun et al. proposent de déterminer la visibilité de chacune des primitives de manière
individuelle en utilisant une requête d’occultation entre deux polygones [95]. L’espace dual étant
également bi-dimensionnel, le problème peut être discrétisé dans une image, ce qui donne la possibi-
lité de réaliser les opérations de soustraction en utilisant la carte graphique. Le mécanisme de requête
de visibilité entre polygones a été étendu à la 3D par Nirenstein et al. [120]. La visibilité du polygone
R est déterminée en commençant par construire un polytope P , représentant l’ensemble de droites
poignardant simultanément les polygones S et R. Pour chaque écran Oi , le polyèdre Oi , représentant
l’ensemble de droites bloquées par Oi , est soustrait de P . Les polygones S et R sont mutuellement
masqués si P est complètement éliminé par ces soustractions successives. Pour utiliser cette requête,
Nirenstein et al. proposent une méthode de calcul de PVS complète, contenant de nombreuses opti-
misations [120].
Une autre approche a été proposée par Bittner et al., qui consiste à représenter toutes les droites
non bloquées (c-à-d. les rayons lumineux) qui quittent le polygone S. Cette idée fut utilisée d’abord
en 2D [24] puis étendue au cas 3D [20]. Les rayons sont encodés dans un arbre d’occultation7 [22],
qui est un arbre <BSP> dans l’espace de Plücker. Chaque nœud interne contient l’équation d’un hy-
perplan, qui correspond à l’arête d’un des écrans. Dans l’espace de Plücker, une feuille de l’arbre
représente soit une région non bloquée (feuille <out>), soit une région complètement bloquée (feuille
<in>). La construction de l’arbre d’occultation nécessite un tri des écrans par ordre de profondeur,
les écrans étant traités du plus proche au plus lointain. Pour chacun des écrans Oi , un polytope Oi ,
représentant l’ensemble des droites poignardant Oi et le polygone S, est construit. Le polytope Oi
est ensuite <filtré> au travers de l’arbre, depuis la racine vers les feuilles. Chaque nœud n rencontré
découpe le polyèdre initial en deux fragments, qui sont ensuite traités dans les deux sous-arbres enra-
cinés en n. Quand un fragment atteint une feuille <out>, le nœud est remplacé par un arbre construit
à partir des hyperplans du polyèdre. Si c’est une feuille de type <in> qui est atteinte, le fragment est
éliminé. Lorsque tous les écrans ont été insérés, l’arbre d’occultation représente l’occultation de la
cellule, et peut être utilisé pour tester l’occultation de toutes les primitives de la scène par rapport à
7 Un arbre d’occultation est appelé <occlusion tree> en anglais.
3 Algorithmes basés sur le 1-squelette des polytopes dans l’espace de Plücker 71
S. Notons que l’idée de stocker la visibilité dans l’espace de Plücker à l’aide d’un arbre BSP avait été
proposée précédemment par Mount et al. [114]. Mora et al. ont proposé récemment de réduire la frag-
mentation du complexe de polyèdres, qui est lui-même obtenu à l’aide de la méthode de Nirenstein et
al. [120], en détectant et en éliminant les découpes inutiles [113].
Remarque : Par rapport au cas 2D, tous les polyèdres du complexe ne représentent pas
nécessairement des ensembles de solutions valides : les polyèdres qui ne possèdent aucune inter-
section avec la quadrique de Plücker ne représentent aucune droite réelle, et doivent également être
éliminés de C [131].
Fan-Tao Pu a prouvé qu’il était possible de tester si un polytope possède une intersection avec la qua-
drique de Plücker à l’aide uniquement de son 1-squelette (c-à-d. ses sommets et ses arêtes) [131] : il
montre que le polytope possède une intersection avec la quadrique s’il possède au moins une arête
E [Vi ; V j ] dont l’un des sommets Vi est à gauche de la quadrique (c-à-d. Hi (Vi ) 0) et dont l’autre est
à droite (c-à-d. H j (V j ) 0). Pour chaque polytope, cette propriété peut être vérifiée afin d’éliminer
du complexe les polytopes qui ne possèdent pas d’intersection avec la quadrique de Plücker.
3 Algorithmes basés sur le 1-squelette des polytopes dans l’espace de

Plücker
Comme nous venons de l’expliquer, deux opérations fondamentales sont nécessaires pour main-
tenir les relations de visibilité dans l’espace de Plücker : un algorithme de découpe de polytopes, et
un algorithme de création d’un polytope représentant l’ensemble des droites poignardant deux poly-
gones. Dans cette section, nous proposons d’effectuer ces tâches en n’utilisant que le 1-squelette des
polytopes et la description combinatoire de leurs sommets (c-à-d la liste des facettes auxquelles ils
appartiennent).
3.1 Algorithme de découpe de polytopes à d dimensions

Soit P un polytope dans Rd , Hi étant l’hyperplan support de sa facette i, Vi un de ses sommets
et E [Vi ; V j ] une de ses arêtes. Nous découpons ce polytope par l’hyperplan Hs pour obtenir les deux
polytopes P et P + .
Notons que cet algorithme est identique quelle que soit la dimension de l’espace Rd dans lequel
on travaille. La Figure 4.4 montre un exemple illustratif en 2D, dans lequel le polytope convexe est un
polygone convexe, et ses facettes sont égales à ses arêtes.
Nous avons indiqué la description combinatoire de chacun des sommets. L’algorithme de découpe
est divisé en 3 étapes : classification des sommets, découpe des arêtes, et finalement création des
nouvelles arêtes :
Etape 1 : La première étape est d’assigner à chacun des sommets Vi une étiquette choisie parmi
l’ensemble f - ; = ; + g8 , en fonction de la position du sommet par rapport à l’hyperplan Hs . Les
sommets situés dans le demi-espace négatif de Hs reçoivent l’étiquette - et sont copiés dans le nou-
veau polytope P , alors que les sommets dans le demi-espace positif reçoivent l’étiquette + et sont
8 Nous avons repris les notations utilisées par Bajaj et al. [11] pour décrire cet algorithme.
(a) (b)
(c) (d)
F IG . 4.4: (a) Le polytope P . (b) Le 1-squelette S de P . (c) Classification des sommets de P en fonction de leur
position par rapport à l’hyperplan de découpe Hs . (d) S et S + après l’opération de découpe .
copiés dans le nouveau polytope P+ . Si un sommet de P appartient au plan de découpe Hs , il reçoit

l’étiquette = , et est ajouté à P et à P + . Hs est ajouté à la description combinatoire du sommet 9 .
Etape 2 : Pour chaque arête E [Vm ; Vn ] reliant deux sommets Vm et Vn de signes différents, un
nouveau sommet Vs , noté = , est ajouté à l’intersection de l’arête et de l’hyperplan Hs . La description
combinatoire de ce sommet est égale à la description combinatoire de l’arête E [Vm ; Vn ], augmentée
de la description combinatoire de l’hyperplan Hs . L’arête découpée E [Vm ; Vn ] de S devient l’arête
E [Vm ; Vs ] de S et l’arête E [Vs ; Vn ] de S + . Les arêtes de S reliant deux sommets - (respectivement
+ ) sont dupliqués dans S (respectivement S + ).
Etape 3 : La dernière étape consiste à créer les nouvelles arêtes des 1-squelettes S et S + des
polytopes P et P + . Toutes les nouvelles arêtes appartiennent à l’hyperplan Hs , et lient ensemble
des sommets étiquetés = . Nous utilisons la description combinatoire des sommets = pour créer les
nouvelles arêtes.
Si le polytope est simple, chaque sommet possède par définition d facettes dans sa description
combinatoire ; les sommets qui doivent être reliés par une arête sont ceux qui possèdent d 1 facettes
en commun dans leur description combinatoire (d 1 étant égal à 4 dans l’espace de Plücker). Si
9 Nous considérons que le point P appartient au demi-espace positif de l’hyperplan H si H (P) > ε, qu’il appartient au
s s
demi-espace négatif si Hs (P) < ε et qu’il est situé sur l’hyperplan dans les autres cas. Le nombre ε est un réel positif,
choisi en fonction de la précision numérique de la machine utilisée (typiquement ε = 10 7 ).
le polytope n’est pas simple, cela signifie que les arêtes peuvent avoir plus de d facettes dans leur
description combinatoire : il est donc possible que les arêtes possèdent également plus de d 1 fa-
cettes. Dans ce cas, une nouvelle arête est créée si les facettes communes possèdent une intersection
qui est une variété de dimension 1 (c-à-d une ligne). Pour vérifier si cette condition est remplie, nous
construisons une matrice à partir de l’équation des hyperplans de toutes les facettes, et vérifions que
le rang de cette matrice est d 1.
3.2 Construction de l’ensemble des droites poignardant deux polygones 3D

3.2.1 Principe général
Dans cette section, nous présentons un algorithme original, permettant de construire le 1-squelette
d’un polytope P , défini dans l’espace de Plücker, dont l’intersection avec la quadrique de Plücker
représente l’ensemble des droites poignardant S et R. Cet algorithme est basé sur la construction
explicite des droites poignardantes extrêmes entre les deux polygones.
(a) (b)
F IG . 4.5: (a) Découpe du polygone S par le plan Pl R contenant R. (b) Configuration initiale des deux polygones.
La ligne r est la droite d’intersection des plans Pl S et PlR . Comme on peut le constater, toutes les droites supports
des arêtes de S et de R sont incidentes à la ligne r.
Soit PlS et PlR les deux plans orientés contenant respectivement les deux polygones S et R. Avant
de calculer P , nous commençons par découper S avec PlR et R avec PlS (cf. Figure 4.5(a)), et ne
gardons que les parties des polygones S et R qui sont situées du côté positif des plans PlR et PlS 10 .
Si un des polygones est situé entièrement du côté négatif du plan de découpe, cela signifie qu’aucune
droite ne poignarde simultanément les deux polygones : le polytope P est l’ensemble vide. Dans le
cas contraire, nous calculons l’équation de la ligne r, définie comme étant la droite d’intersection des
plans PlS et PlR 11 (cf. Figure 4.5(b)).
Les arêtes des deux polygones sont transformées en hyperplans dans l’espace de Plücker, et
forment un polyèdre projectif. Après sa projection sur un hyperplan de projection arbitraire, le polyèdre
est une <pyramide> infinie dont le sommet est le point R , qui correspond dans l’espace primal à la
droite r (cf. Figure 4.6). En effet, toutes les droites supports des arêtes ei des deux polygones sont inci-
dentes à la droite r, ce qui signifie que le point dual R est situé à l’intersection de tous les hyperplans
Hei correspondants.
10 Une telle opération de découpe de polygone est appelée opération de <clipping> en anglais.
11 Si Pls et Plr sont parallèles, la droite d’intersection r est rejetée à l’infini : les coordonnées du point R sont alors
(0; 0; 0; nx ; ny ; nz ), dans laquelle n(nx ; ny ; nz ) est la normale au plans Pls (la normale au plan Plr étant alors évidemment
égale à n).
(a) (b)
F IG . 4.6: Propriété géométrique du polyèdre P . (a) Après sa projection sur un hyperplan de projection arbi-
traire : le sommet R de la pyramide appartient à la quadrique de Pl ücker. (b) Après sa projection sur H? : R
devient un point à l’infini. L’intersection des arêtes verticales du polyèdre avec la quadrique de Pl ücker sont
les points Si0j , qui correspondent aux droites poignardantes extr êmes. (Il s’agit d’une évocation, car le polyèdre
est en réalité compris dans un hyperplan dans R 6 . Par souci de clarté, nous n’avons représenté que 5 des 16
arêtes verticales qui définissent le polyèdre dans cette configuration).
La pyramide pourrait éventuellement être dégénérée si r était une droite poignardante, mais nous
évitons cette situation par la découpe initiale des deux polygones. L’ensemble des droites qui poi-
gnardent les deux polygones est transformé en un ensemble de points situés à l’intersection de la qua-
drique de la pyramide et de la quadrique de Plücker. Par définition, une droite poignardante extrême
est tangente à quatre arêtes : étant donné la configuration à laquelle nous avons à faire (deux poly-
gones convexes), toute droite poignardante contiendra un sommet Pi de S et un sommet Pj de R, et
nous la notons si j . Dans l’espace projectif, elle est transformée en un rayon Sij , situé à l’intersection
des arêtes de la pyramide avec la quadrique de Plücker, et devient le point Si0j après la projection de la
pyramide sur un hyperplan de projection (cf. figure 4.6 (a)).
L’algorithme de découpe de la section 3.1 nécessite que le polyèdre soit borné, et nous utilisons les
étapes suivantes pour transformer le polyèdre projectif en un polytope. Tout d’abord, nous choisissons
un hyperplan de projection particulier, noté H? , de telle sorte que le point R devienne un point
à l’infini, correspondant à la direction r (les détails sont donnés dans le paragraphe 3.2.2.1). La
projection sur l’hyperplan H? transforme le polyèdre projectif en un prisme dont les arêtes verticales
sont parallèles à la direction r (cf. Figure 4.6 (b)). Il est plus simple de borner ce prisme que de borner
la pyramide infinie obtenue à l’aide d’un plan de projection arbitraire. En effet, deux hyperplans Hc+
et Hc , de normales r et r , sont suffisants pour borner un polyèdre. Les termes indépendants de
ces hyperplans supplémentaires, fixant leur translation, sont choisis de telle sorte qu’ils englobent
complètement la région de la quadrique de Plücker située à l’intérieur du prisme (cf. Figure4.7) (Les
détails du choix des termes indépendants sont donnés dans le paragraphe3.2.2.2).
Dans l’espace de Plücker, un sommet d’un polyèdre P est situé à l’intersection de cinq hyper-
plans 12 . Quatre d’entre eux correspondent aux arêtes des deux polygones, et le cinquième est l’un des
hyperplans Hc+ ou Hc . La position des sommets est calculée comme étant à l’intersection des arêtes
verticales du prisme et des hyperplans Hc+ et Hc . Cette opération peut être réalisée simplement, en
12 Nous avons supposé que le polyèdre était simple, et que chacun de ses sommets était contenu dans cinq facettes
exactement ; cette contrainte est vérifiée pour les polygones S et R qui ne contiennent pas d’arête dégénérée.
F IG . 4.7: Sur les hyperplans Hc+ et Hc , les deux sommets Vi+j et Vi j , qui correspondent à la droite poignar-
dante si j , ont entre eux quatre hyperplans en commun, et ont quatre hyperplans en commun avec les sommets
correspondant aux droites fs i+1 j ; si 1 j ; si j+1 ; si j 1 g.
construisant des droites parallèles à r , chacune d’entre elles passant par un des points Sij .
Les arêtes du polyèdre étant situées à l’intersection de quatre hyperplans, cela signifie que les
arêtes qui doivent être créées relient des paires de sommets possédant quatre hyperplans en commun
(cf. Figure 4.7).
3.2.2 Description de l’algorithme

L’algorithme complet pour construire le 1-squelette de P se déroule donc comme suit :
1. Calcul de la droite r et découpe des polygones S et R par les plans PlR et PlS respectivement.
2. Calcul de la direction r et de toutes les droites poignardantes extrêmes si j , de même que leur
point dual en coordonnées de Plücker Sij .
3. Calcul de l’hyperplan de projection H? , et projection des points Sij sur H? pour obtenir les
points Si0j .
4. Placement des deux plans supplémentaires, Hc+ et Hc :
– la normale de ces plans est r et r .
– leur terme indépendant est calculé afin que tous les points correspondant à des droites poi-
gnardantes soient situés à l’intérieur du polytope (cf. paragraphe3.2.2.2).
5. Calcul des sommets Vi+j et Vi j du polytope, chacun d’entre eux étant situé à l’intersection d’une
arête verticale du polytope passant par un des points Si0j avec les hyperplans Hc+ et Hc .
6. Création des arêtes : pour chaque droite poignardante extrême si j , connecter :
– le sommet Vi+j et le sommet Vi j , pour former une arête verticale.
– le sommet Vi+j et les sommets Vi+1 j , Vi+ + +
+1 j , Vi j 1 , Vi j+1 .
– le sommet Vi j et les sommets Vi 1 j , Vi+1 j , Vi j 1 , Vi j+1 .
3.2.2.1 Choix de l’hyperplan de projection H? Soit R (r0 ; :::; r5 ) un point de P5 et H? un hyper-
plan de projection d’équation ∑5i=0 ai xi = b. Le point R peut être vu comme un rayon de R6 passant
par l’origine, de coordonnées (tr0 ; :::; tr5 ) avec t 2 R+ . La projection du rayon R sur l’hyperplan H?
revient à calculer le point d’intersection de ce rayon avec H? ; ce point est obtenu lorsque t est égal à
tint = b=(∑5i=0 ai ri ). Nous sommes libre de choisir l’hyperplan de projection H? . Afin de transformer
R en un point à l’infini, nous avons choisi de prendre H? πr3 x0 + πr4 x1 + πr5 x2 + πr0 x3 + πr1 x4 + πr2 x5 =
1. Puisque r est une droite réelle, R appartient à la quadrique de Plücker. Dès lors, nous avons
∑5i=0 ai ri = Hr (R ) = 0 (par l’équation (2.15) du chapitre 3). Si l’on prend cet hyperplan H? comme
hyperplan de projection, le point R est effectivement transformé en un point à l’infini, c-à-d. une
direction, notée r .
3.2.2.2 Calcul des termes indépendants de Hc+ et Hc Les termes indépendants sont choisis pour
que tous les points correspondant à des droites poignardantes soient situés à l’intérieur du polytope.
Ce sera le cas si les deux conditions suivantes sont réunies :
– tous les points Si0j , correspondant aux droites poignardantes extrêmes, sont à l’intérieur du po-
lytope.
– un éventuel extremum local de la quadrique est également situé à l’intérieur du polytope.
Soit di j la projection orthogonale de Si0j sur la direction r , calculée à l’aide d’un produit scalaire
classique dans R6 : di j =< s0
i j ; r >. Les deux conditions seront vérifiées si l’on prend comme termes
+
indépendants pour les plans Hc et Hc les valeurs minimum et maximum de tous les di j (condition
1), et si l’on seuille ces valeurs à zéro pour tenir compte de la courbure de la quadrique de Plücker
(condition 2).
3.2.3 Comparaison avec l’état de l’art

Contrairement à l’approche basée sur l’algorithme d’énumération de sommets, notre méthode di-
recte, basée sur la construction des droites poignardantes extrêmes et sur les propriétés géométriques
du polytope fournit toujours un résultat valide. Dans sa thèse de doctorat, Shaun Nirenstein pro-
pose également un algorithme direct de construction pour générer le polytope P [118], et la méthode
présentée ici reprend plusieurs de ses idées. Tout d’abord, nous transformons également le polytope
P en un prisme, grâce à un choix approprié de l’hyperplan de projection. Mais la technique proposée
par Shaun Nirenstein nécessite que la ligne r fasse partie du plan de coordonnées yz = 0 : la scène
doit donc subir une rotation avant chaque requête pour amener le polygone R dans ce plan, et la droite
r dans la position adéquate. Notre choix d’hyperplan de projection est plus général, puisqu’il fonc-
tionne avec une droite r en position quelconque : notre algorithme a donc l’avantage de ne nécessiter
aucune rotation de la géométrie. Nous avons également repris l’idée d’utiliser deux hyperplans de
découpe, placés perpendiculairement à l’axe vertical du prisme, pour borner le polyèdre P . Nous pro-
posons cependant un nouveau calcul des termes indépendants, qui est moins conservatif que celui
proposé par Nirenstein, et qui fournit un polytope P plus proche du polytope optimum. Il en résulte
moins de découpes inutiles. Nous ne prétendons cependant pas avoir calculé les bornes optimales, et
considérons que leur détermination est un travail futur intéressant.
3.3 Complexité théorique des algorithmes

Soit c le nombre de sommets = . Au total, l’algorithme de découpe nécessite de parcourir une fois
l’ensemble des sommets Vi , une fois l’ensemble des arêtes Ei et de comparer 12 c(c 1) descriptions
combinatoires13 . La complexité de l’algorithme de découpe est donc en O(12 c(c 1) + jVi j + jAij).
13 Par souci d’efficacité lors de ces comparaisons, les descriptions combinatoires sont triées par ordre croissant.
L’algorithme de création nécessite de parcourir une et une seule fois chaque droite poignardante
extrême. Etant donné qu’il existe nm droites poignardantes extrêmes, si m et n sont le nombre de
sommets de chacun des deux polygones initiaux, la complexité de l’algorithme de création est donc
O(mn) [118].
4 Requête simple et efficace d’occultation entre deux polygones

Une requête d’occultation entre deux polygones consiste à déterminer si les polygones S et R sont
mutuellement visibles malgré un ensemble d’écrans convexes polygonaux Oi placés entre eux. Après
avoir construit le polytope P , représentant l’ensemble des droites poignardant S et R, les ensembles
de droites bloquées par chacun des écrans sont soustraits de manière incrémentale et les polytopes
résultants sont stockés dans le complexe C . Les approches précédentes [113] traitent individuelle-
ment chacun des écrans Oi , et utilisent chacune des arêtes de chacun des écrans comme hyperplan
de découpe dans l’espace dual ; il en résulte beaucoup de calculs inutiles. De plus, leur efficacité
est prise en défaut lorsque les deux polygones ne sont que partiellement visibles, car leur visibilité
mutuelle ne peut être établie que lorsque tous les écrans ont été soustraits. Dans cette section, nous
présentons une nouvelle méthode, utilisant les algorithmes présentés dans la section3, pour résoudre
ces problèmes. Nous présentons d’abord les deux nouvelles idées sur lesquelles la technique repose :
un nouveau procédé de détection des écrans guidée par la visibilité (section 4.1), et une nouvelle
méthode d’agrégation d’écrans basée sur leur silhouette étendue (section4.2). La méthode complète,
combinant ces deux idées, est présentée dans la section4.3 et discutée dans la section 4.4.
4.1 Sélection des écrans guidée par la visibilité

Au cours d’une requête, le polytope P est découpé par les hyperplans correspondant aux arêtes
des écrans, et les polytopes correspondant aux régions bloquées de l’espace des droites sont éliminés.
Chacun des polytopes restants représente un sous-ensemble de l’ensemble initial de droites poignar-
dantes : celles qui ne sont pas bloquées par les écrans traités précédemment. En d’autres termes, cha-
cune des droites de ce sous-ensemble passe par une ouverture laissée par les écrans (cf. Figure4.8).
F IG . 4.8: Pi représente un ensemble de droites au travers d’une ouverture laiss ée par les écrans. La droite m
est une <droite représentative> de Pi .
Pour chaque polytope Pi , nous extrayons une de ces droites, appelée droite représentative et
notée m, et nous calculons son intersection avec les écrans. Si m ne rencontre aucun écran, S et R
sont mutuellement visibles et la requête s’arrête. Dans le cas contraire, l’écran suivant Oi , qui doit
être soustrait de P , est sélectionné parmi les polygones traversés par m. Lorsque Oi a été choisi, son
polytope Oi , ne sera pas soustrait de tous les polytopes du complexe comme cela était réalisé dans les
travaux précédents [120], mais Oi est uniquement soustrait du polytope Pi . Etant donné que l’écran
a été choisi en calculant l’intersection de la droite représentative m avec la géométrie de la scène,
cette procédure nous garantit que Oi contient au moins le point M de Pi , et que l’intersection entre
Pi et Oi n’est jamais vide (cf. figure 4.9). De plus, chacune des opérations de soustraction modifie
l’intersection du polytope Pi et de la quadrique de Plücker, et toutes les découpes qui n’auraient enlevé
aucune des droites poignardantes sont éliminées. Par rapport à la méthode présentée récemment par
Mora et al. [113], l’avantage de ce procédé de sélection des écrans est que toutes les opérations de
découpe sont éliminées, avant même d’avoir dû être effectuées.
4 Requête simple et efficace d’occultation entre deux polygones 79
F IG . 4.9: (a) Même si les hyperplans de Oi possèdent une intersection avec P i , ces deux opérations de découpe
sont inutiles puisque O i \ P est vide. (b) Grâce à notre stratégie d’échantillonnage par ligne repr ésentative,Oi \
P n’est jamais vide, et l’intersection contient au moins M .
La droite représentative m du polytope Pi est calculée dans l’espace de Plücker, dans lequel les
polytopes sont des ensembles convexes plutôt que dans l’espace primal R3 dans lequel chaque poly-
tope représente un ensemble de droites moins facile à manier 14 . Dans l’espace dual, le point M doit
respecter les contraintes suivantes :
– être situé à l’intérieur de Pi : toutes les combinaisons linéaires de ses sommets fournissent un
point valide.
– appartenir à la quadrique de Plücker.
Pour trouver M , nous calculons deux combinaisons linéaires de sommets, situées de part et
d’autre de la quadrique de Plücker, et qui définissent ensemble un segment de droite ; l’intersection de
ce segment de droite avec la quadrique de Plücker est le point M . S’il n’est pas possible de trouver
un point de chaque côté de la quadrique, une droite poignardante extrême est choisie comme droite
représentative 15 .
Lorsque la droite représentative m d’un polytope traverse plusieurs écrans, il est nécessaire de
sélectionner lequel sera retenu parmi les écrans traversés. Nous utilisons une stratégie de comptage de
rayons, similaire à celle utilisée par Nirenstein et al. [120] dans le cas d’un échantillonnage aléatoire :
chacun des écrans maintient un compteur qui représente le nombre de droites représentatives qui le
traversent ; l’écran choisi est celui qui est traversé par le plus de droites représentatives. Pour un po-
lytope Pi donné, seul un sous-ensemble de droites représentatives est pris en compte : celles dont le
point dual est situé à l’intérieur de Pi . Evidemment, chaque fois qu’un polytope est éliminé, sa droite
représentative est également supprimée du système de comptage. Il est possible de réduire le nombre
d’intersections à effectuer en <recyclant> les droites représentatives : chaque découpe crée deux sous-
polytopes, et la ligne m peut être réutilisée de nouveau comme droite représentative pour l’un d’entre
eux (c-à-d pour celui qui est situé du même côté de l’hyperplan de découpe que M ).
4.2 Agrégation des écrans basée sur leur silhouette étendue

Soit un écran composé d’un maillage polygonal.
La silhouette ponctuelle de cet écran, définie par rapport à un point P, est l’ensemble des arêtes ei
qui joignent deux polygones F1 et F2 du maillage, et tels que l’un d’entre eux fait face à P et l’autre
non (cf. Figure 4.10(a)).
14 Ces ensembles sont des classes isotopiques de droites, qui ne sont pas convexes ; de plus, ces ensembles sont délimités
par les surfaces critiques, qui ne sont ni convexes ni planes.
15 Cette situation arrive dans des situations dégénérées, lorsque tous les sommets du polytope sont du même côté de la
quadrique ou appartiennent à la quadrique.

De manière formelle,une arête e fait partie de la silhouette ponctuelle depuis le point P 2 R3 si et

seulement si :

< (OV1 OP); n1 > 0
< (OV2 OP); n2 > 0 (4.1)
Vi étant un sommet quelconque du polygone Fi et ni étant la normale extérieure de ce dernier [137].
F IG . 4.10: (a) L’arête appartient à la silhouette ponctuelle vue depuis le point P puisque les projections des
normales n1 et n2 sur le vecteur OV OP ne sont pas de même signe (V1 et V2 sont identiques et égaux au point
V sur le dessin). (b) L’arête appartient à la silhouette étendue par rapport à R et à S. (c) L’arête sera une arête
interne (et ce, quelle que soit la position de S), car il est impossible de trouver un point P R 2 R tel que l’arête
appartienne à la silhouette ponctuelle vue depuis PR .
Nous définissons la silhouette étendue d’un écran par rapport à deux polygones S et R comme
étant l’ensemble des arêtes faisant partie de la silhouette ponctuelle simultanément pour un point du
polygone S et pour un point du polygone R (cf. Figure 4.10(b)). Une arête qui n’appartient pas à la
silhouette étendue est appelée arête interne (cf. Figure 4.10(c)). De manière formelle, une arête e fait
partie de la silhouette étendue par rapport aux polygones S et R si et seulement s’il existe un point
Pr 2 R et un point Ps 2 S tel que [137] :
8
>
>
< < (OV1 OPr ); n1 > 0
< (OV2 OPr ); n2 > 0
>
>
: < (OV1 OPs); n1 > 0 (4.2)
< (OV2 OPs); n2 > 0
Dans le cas d’écrans composés de maillages polygonaux, seules les arêtes appartenant à la sil-
houette étendue des objets peuvent créer des événements de visibilité (c-à-d peuvent séparer l’espace
de Plücker entre un ensemble de droites bloquées et un ensemble de droites libres). Les autres arêtes
(c-à-d les arêtes internes) sont inutiles pour la détermination de la visibilité (cf. Figure4.11).
(a) (b)
F IG . 4.11: (a) La région en grisé représente l’ensemble des rayons bloqu és par les écrans. Les arêtes b et e
sont des arêtes internes, alors que les arêtes a, c et d font partie de la silhouette étendue. (b) Seules les arêtes
de la silhouette étendues doivent être utilisées pour obtenir l’ensemble des rayons bloqu és.
Plutôt que de découper le complexe de polytopes avec toutes les arêtes de tous les écrans, il est pos-
sible d’éviter de nombreuses découpes inutiles en vérifiant que les arêtes de découpe font bien partie de
la silhouette étendue. Une idée similaire a été utilisée très récemment pour le calcul d’ombres douces
avec un algorithme de lancer de rayons : la silhouette étendue des objets y est exploitée pour accélérer
le calcul de la quantité de lumière reçue par une primitive éclairée par une lampe étendue [97].
Soit e l’arête d’un écran, qui connecte les deux polygones P1 et P2 . Les plans contenant P1 et P2
définissent une région en forme de double coin, qui délimite les régions W1 et W2 (cf. Figure 4.12).
Les arêtes qui appartiennent à la silhouette étendue possèdent un double coin qui a une intersection
avec les deux polygones S et R. Nous en déduisons la condition pour qu’une arête appartienne à la
silhouette étendue (cf. Figure 4.13 pour différents exemples illustratifs) :
<e fait partie de la silhouette étendue si et seulement si S a au moins un point dans W1 (respectivement
dans W2 ) et si R a au moins un point dans W2 (respectivement dans W1 ).>
(a) (b)
F IG . 4.12: L’arête e relie les polygones P1 et P2 . Les plans contenant P1 et P2 définissent une région en double
coin. (a) Vue 3D. (b) Vue 2D, projet ée perpendiculairement à l’arête e.
F IG . 4.13: Quelques exemples illustrant la condition d’appartenance à la silhouette. Les arêtes a et b appar-
tiennent à la silhouette étendue, contrairement aux ar êtes c et d.
La silhouette étendue partitionne le maillage de l’écran en <patches> Fi de polygones connectés

(c-à-d chaque polygone de l’écran appartient à un et un seul <patch> Fi , cf. Figure 4.14).
Dans notre système de comptage de droites utilisé pour la sélection des écrans, chacun des <pat-
ches> est considéré comme étant un écran. Etant donné que les silhouettes dépendent de la configura-
tion des polygones S et R, les <patches> Fi sont extraits explicitement lors de chacune des requêtes, la
première fois qu’un écran polygonal est atteint par un rayon. L’extraction utilise un processus de rem-
plissage 16 du graphe d’adjacence du maillage de l’écran qui s’arrête lorsqu’une arête de la silhouette
étendue est rencontrée.
16 Appelé <floodfill> en anglais.

(a) (b)
F IG . 4.14: Utilisation d’un maillage polygonal comme écran pour une requête d’occultation (S et R ne sont
pas représentés, mais ils sont situés de part et d’autre de chacun des lapins). (a) Approche classique : les
polygones sont traités individuellement, et toutes les arêtes sont utilisées. (b) Agrégation basée sur la silhouette
étendue : les polygones sont regroup és en <patches>, et seules les arêtes appartenant à la silhouette étendue
sont utilisées.
4.3 Algorithme pour une requête d’occultation analytique entre deux polygones
Notre algorithme utilise les nouvelles techniques décrites précédemment, et peut être résumé par
le pseudo-code suivant :
1: Procédure areVisible(S, R)
2: Construction du polytope initial P , pour S et R
3: retourne recursiveSplit(P )
4: Procédure recursiveSplit (P )
5: m = ligne représentative de P
6: X = ensemble des <patches> traversés par m
7: si X = vide alors
8: retourne Visible //terminaison précoce
9: Sélectionne un <patch> Fi de X
10: Recherche une arête e valide de Fi
11: si e 6= vide alors
12: fP ,P + g = Découpe (P , He )
13: si (recursiveSplit(P ) = Visible alors
14: retourne Visible
15: si (recursiveSplit(P + ) = Visible alors
16: retourne Visible
17: retourne Occulté
Le complexe C n’est pas représenté de manière explicite, mais implicitement par des appels suc-
cessifs à la procédure récursive recursiveSplit(P ). Pour chaque polytope, une droite représentative m
est extraite et son intersection avec la géométrie de la scène est calculée pour sélectionner Fi (lignes 6
et 7). Comme cela a été décrit dans la section 4.1, m passe au travers d’une ouverture laissée par les
écrans déjà traités. Si m ne rencontre pas d’écran, les deux polygones sont mutuellement visibles et
la requête s’arrête de manière précoce (ligne 9). Dans le cas contraire, le <patch> Fi est choisi parmi
l’ensemble de <patches> poignardés par m (ligne 10). Ses arêtes frontières sont inspectées jusqu’à ce
qu’une arête e vérifiant la condition de découpe suivante soit découverte (ligne 11) :
8
< He , l’hyperplan dual de e, n’est pas une facette de P .
: e appartient à la silhouette étendue (cf. section 4.2).
e divise l’ensemble des droites à l’intérieur du polytope P .
Ce dernier test n’est pas trivial ; nous l’évaluons de manière conservative, en testant si l’arête e
possède une intersection avec l’enveloppe convexe de S et de R.
Pour vérifier si He est une facette de P , un drapeau est associé à chaque arête de la scène : les drapeaux
sont mis à jour au fil de appels récursifs, pour indiquer les arêtes qui ont déjà été utilisées comme hy-
perplan de découpe pour obtenir le polytope P .
Si aucune arête vérifiant les trois conditions n’est trouvée, le polytope P représente un ensemble de
droites complètement bloquées par le <patch> Fi (on dira que le polytope est bloqué) : la procédure
récursive s’arrête, et le polytope est éliminé du complexe. Dans le cas contraire, le polytope est
découpé en deux polytopes, P et P + (ligne 13) et la procédure est appliquée de manière récursive
aux deux polytopes (lignes 14-17). La procédure récursive s’arrête lorsque tous les polytopes ont été
bloqués : S et R sont mutuellement occultés (ligne 18).
4.4 Analyse de la méthode

Le principal avantage de cet algorithme est que toutes les découpes par des arêtes internes sont
évitées. Le meilleur cas est celui d’un seul écran convexe bloquant tous les rayons entre les deux poly-
gones : toutes les arêtes sont internes et l’occultation des polygones est détectée sans devoir effectuer
la moindre découpe. Dans un sens, cet algorithme peut être vu comme l’extension au cas général
d’écrans multiples des prédicats proposés par Navazo et al. pour détecter l’occultation générée par un
seul écran isolé [116].
En termes de couches d’occultation 17 [91], les algorithmes précédents de calcul exact de visibi-
lité depuis une région étaient uniquement capables de fusionner l’occultation à partir de la seconde
couche masquée ; pour ce faire, les boı̂tes englobantes des objets qui ont été déterminés comme étant
masqués depuis S sont utilisées ensuite comme écrans virtuels pour le reste du calcul [120]. Notre
méthode d’agrégation d’écrans permet en plus de combiner l’occultation de la première couche visible
d’écrans : cette propriété est primordiale pour pouvoir utiliser la méthode lorsque la scène contient
des objets complexes.
Les chances pour que le résultat soit atteint sans exécuter la totalité de la procédure récursive
(ce que nous appelons terminaison précoce de l’algorithme) sont également augmentées de manière
considérable dans le cas de la visibilité mutuelle, étant donné qu’une ligne représentative m est testée
pour chaque ouverture. L’algorithme converge effectivement vers les ouvertures et s’arrête. De plus,
17 Les couches d’occultation sont les <Occlusion layers> en anglais.
la complexité de la méthode n’est plus fonction du nombre d’écrans polygonaux entre les polygones
S et R, mais est fonction de la complexité de la silhouette étendue, qui est généralement beaucoup
plus simple18 . Finalement, la combinaison de l’utilisation des silhouettes et de la stratégie des droites
représentatives permet une détection très efficace des ouvertures, car les droites sont guidées vers le
bord des objets.
4.5 Relation entre l’algorithme de soustraction et la visibilité analytique

Il existe un rapport direct entre les polytopes du complexe C et la visibilité analytique. Ce rapport
fut d’abord étudié par Pellegrini [125], dans le cadre de travaux théoriques sur la visibilité, puis ensuite
par Teller qui l’utilisa pour le calcul de visibilité au travers d’une séquence de portails [154]. Nous en
présentons ici une explication, inspirée de la thèse de Jiřı́ Bittner [20] dans le cas 2D puis dans le cas
3D.
4.5.1 Dans R2
Dans le plan, les écrans Oi et les polygones S et R sont réduits à des segments de droite. L’espace
dual utilisé est l’espace de Plücker 2D (cf. rappel page 28). L’algorithme commence par créer un
polytope P représentant l’ensemble des droites poignardant S et R. Pour obtenir P , les quatre points
de l’espace primal Pi sont convertis en quatre droites HPi dans l’espace dual (cf. Figure 4.15). Chacune
de ces droites délimite un demi-espace. Le polytope P est le polygone convexe, intersection des demi-
espaces positifs délimités par ces quatre droites. On constate sur la Figure que les sommets Sij du
polytope P correspondent dans l’espace primal R2 aux droites poignardantes extrêmes si j des deux
segments S et R. En effet, en 2D les droites poignardantes extrêmes sont les droites bi-tangentes [54].
(a) Espace primal (b) Espace dual (après projection)
F IG . 4.15: (a) Deux segments S et R dans R 2 . (b) Le polytope P dans l’espace dual de Pl ücker 2D, représentant
l’ensemble des droites poignardant ces deux segments (apr ès projection).
Soit un écran P4 P5 : la soustraction des droites bloquées consiste à soustraire de P le polytope

formé par les deux droites HP4 et HP5 (cf. Figure 4.16). La technique consiste à découper successive-
ment P par les deux droites HP4 et HP5 puis à éliminer le polytope correspondant aux droites bloquées
par le segment P4 P5 (indiqué en grisé sur la Figure) : dans l’espace primal, ce polytope correspond à
la zone d’ombre créée par l’écran P4 P5 . Après cette opération de soustraction, l’ensemble des droites
18
p
D’après [137], la complexité de la silhouette ponctuelle est O( (n)), avec n le nombre de faces du maillage, pour une
<classe importante d’objets>. A notre connaissance, la complexité de la silhouette étendue n’a pas encore été étudiée dans
la littérature.
poignardant S et R et qui ne sont pas bloquées par l’écran sont représentées par un complexe de 2
polytopes. Les sommets Sij de ces polytopes correspondent de nouveau aux points duals des droites
poignardantes extrêmes si j de la scène.
(a) Espace primal R2 (b) Espace dual des droites (après projection)
F IG . 4.16: Soustraction de l’écran P4 P5 du polytope P
Nous avons représenté dans la Figure 4.18 les polytopes obtenus pour différentes positions d’un
écran, ainsi que les polytopes obtenus lorsque l’on soustrayait plusieurs écrans successivement. Dans
l’espace primal, les zones d’ombre générées par les écrans sont représentées en gris foncé et les zones
de pénombre en gris clair. On constate dans la dernière configuration le point fort de la méthode : elle
permet de tenir compte de l’effet cumulé de plusieurs écrans (processus de <fusion des écrans>, cf.
page 47).
4.5.2 Dans R3
Comme dans R2 , l’algorithme commence par créer le polytope P dans l’espace dual de Plücker,
P représentant l’ensemble des droites poignardant simultanément les polygones S et R. Comme nous
l’avons vu page 54, le polytope P est obtenu en utilisant l’équation (2.11) du chapitre 3 pour trans-
former les droites supports des arêtes des polygones S et R en hyperplans dans l’espace de Plücker.
L’ensemble des droites poignardantes est représenté par la portion de la quadrique de Plücker qui est
délimitée par le polyèdre. En particulier, le point dual B de la droite poignardante b est situé sur la
quadrique de Plücker, et situé à l’intérieur du polyèdre (cf. Figure4.17).
F IG . 4.17: Correspondance entre l’espace primal 3D et l’espace dual de Pl ücker (il s’agit d’une évocation
de la réalité, car l’espace de Pl ücker est en réalité P5o ). Les arêtes des polygones S et R sont transform ées en
hyperplans dans l’espace dual de Pl ücker. Les hyperplans délimitent le polyèdre courbe Q sur la quadrique de
Plücker.
(a) Espace primal R2 (b) Espace dual des droites (après projection)
F IG . 4.18: Différentes configurations d’ écrans en 2D, avec le résultat de la soustraction des droites bloqu ées
par ces écrans dans l’espace dual. Les sommets des polytopes de l’espace dual correspondent aux droites
poignardantes extrêmes dans l’espace primal. On constate sur la derni ère Figure que l’algorithme réalise
effectivement la fusion des pénombres.
Nous notons Q la portion de quadrique délimitée par le polytope P . Il s’agit également d’un
<polytope> convexe, mais qui est courbe, puisqu’il appartient à la surface de la quadrique. Ce <po-
lytope> Q est donc le sous-ensemble de droites réelles du polytope P . La Figure 4.17 donne une
représentation schématique de Q , comme étant la portion de la quadrique délimitée par l’ensemble
d’hyperplans duaux des arêtes de S et de R. En pratique, nous ne manipulons jamais explicitement
le polyèdre courbe Q , mais nous travaillons plutôt avec le polyèdre P et calculons, si nécessaire,
l’intersection de ses arêtes avec la quadrique de Plücker.
Une fois le polytope P calculé, l’algorithme est semblable à celui présenté dans R2 et consiste à
découper le polytope P par les hyperplans Hi . Ces hyperplans sont les hyperplans duaux des droites
supports des arêtes ei des différents écrans. On élimine ensuite du complexe C obtenu les polyèdres
représentant les ensembles de droites bloquées. Le résultat est un ensemble de n polytopes convexes,
formant un complexe C fP0 ; ::; Pn g. Comme ci-dessus, l’intersection de chacun des polytopes Pi avec
la quadrique de Plücker est le polytope courbe Qi .
F IG . 4.19: Soit Ci un ensemble de points pris le long d’une des courbes d élimitant le <polytope> courbe Q
(qui est lui-même la trace sur la quadrique de Pl ücker du polytope P ).
Soit Ci un ensemble de points échantillonnés le long d’une des courbes délimitant un polytope
Qi (cf. Figure 4.19). Dans l’espace primal, ces points correspondent aux droites ci , qui décrivent une
surface réglée du second degré, qui n’est autre qu’une surface critique (cf. Figure 4.20). En effet,
chacun des points Ci appartient à une arête courbe de Q , ce qui signifie qu’il appartient à une 2-face
du polytope P . Il est donc situé à l’intersection de 3 hyperplans. Dans l’espace primal, cela signifie
que la droite est tangente à 3 arêtes de polygones de la scène. De même, les sommets Si du polytope
Q appartiennent à une 1-face du polytope P (c-à-d une arête). Ils sont donc situés à l’intersection de
4 hyperplans, ce qui signifie qu’ils sont tangents à quatre arêtes de polygones dans l’espace primal.
Les points Si sont donc les points duaux des droites poignardantes extrêmes si de la scène [153].
Ces polytopes Qi sont donc en quelque sorte les analogues dans R3 des polygones dans l’espace dual
présentés au paragraphe précédent.
F IG . 4.20: Relation entre un polytope P i et la visibilité analytique : l’intersection des 2-faces du polytope et de
la quadrique de Pl ücker décrivent des courbes, qui délimitent le polytope Q i . Chaque point Ci appartenant à
cette courbe correspond dans l’espace primal à une droite ci , appartenant à une surface critique.
Notons pour conclure que chaque polytope Pi représente une classe isotopique de droites [118] :
toutes les droites réelles représentées dans Pi (c-à-d toutes les droites de Qi ) franchissent les droites
supports des arêtes des polygones de la scène de manière identique. En d’autres termes, il est toujours
possible de déplacer une droite a 2 Qi en une droite b 2 Qi de manière continue, de telle manière que
la droite a ne croise jamais la droite support d’une des arêtes de la scène.
5 Résultats
Nous avons implémenté les différents algorithmes décrits et les avons regroupés dans la librai-
rie <Visilib>. Dans la section 5.1, nous évaluons les performances de la requête de visibilité dans
différentes scènes. Nous étudions ensuite dans la section5.2 les mécanismes de sélection des écrans et
de détection des ouvertures au moyen d’une scène synthétique. Toutes les évaluations ont été réalisées
à l’aide d’un ordinateur portable de type Pentium 4 (1.9Ghz) comportant 1.28 Gb de mémoire centrale.
5.1 Evaluation des performances de l’algorithme

5.1.1 Description des scènes de test
La première scène de test est un modèle représentant la ville de Vienne, et est composé de 458
objets et de 26k triangles 19 . Cette scène 2D 12 a été obtenue en élevant les façades verticalement à partir
du plan des bâtiments. Il s’agit d’une scène de test classique en <occlusion culling>, car l’occultation
y est très importante, et seule une petite partie des bâtiments est visible lorsqu’on se déplace dans les
rues (cf. Figure 4.21).
Les deux scènes suivantes, appelées <Niveau 12> et <Niveau 1> sont deux scènes de la firme
Appeal, provenant de leur dernier jeu vidéo <Outcast 2>. Un algorithme de radiosité 20 leur a été
appliqué, pour simuler l’éclairage global. Cet algorithme a subdivisé les maillages des modèles pour
approcher les limites de discontinuité de la fonction d’éclairement (limites d’ombres et de pénombres),
et il en résulte un maillage relativement dense. La scène <Niveau 12> représente une usine, composée
de 1177 objets et de 115k triangles. L’occultation y est principalement générée par les murs, mais
ces derniers sont composés, comme le reste de la scène, de maillages polygonaux subdivisés par
l’algorithme de radiosité. La scène du <Niveau 1> est une scène d’extérieur de 2160 objets et de 188k
triangles, qui représente un vaisseau spatial échoué dans un paysage de jungle. Il est nécessaire de
réaliser la fusion des écrans dans cette scène, car l’occultation est souvent générée simultanément par
plusieurs maillages polygonaux séparés. De plus, ces deux scènes sont des candidates idéales pour
l’agrégation d’écrans, puisque les objets sont des maillages quelconques détaillés suite à la méthode
de radiosité.
La dernière scène utilisée, appelée <Bonga>, est un modèle <CAD> représentant un bateau uti-
lisé pour le transport du pétrole, et compte 4.6 millions de triangles pour 430k objets. Elle nous a été
fournie par l’entreprise VRContext comme exemple de scène complexe utilisée dans l’industrie. Cette
scène est composée d’une multitude d’objets de petite taille souvent très détaillés (vannes, extincteurs,
etc.), d’objets fins et étendus (tuyaux, poutrelles métalliques,etc.) et de larges polygones horizontaux
représentant les plaques d’acier formant le pont du navire. L’occultation entre les étages est principa-
lement due à ces plaques, mais celle existant au sein d’un pont du navire est générée par l’ensemble
de tuyaux et de poutrelles. Il s’agit donc d’une scène difficile à traiter, puisqu’elle nécessite de réaliser
la fusion complète des écrans pour détecter l’occultation générée par les ensembles de tuyaux.
19 http ://www.cg.tuwien.ac.at/research/vr/urbanmodels/index.html#Models%202000
20 Les méthodes de radiosité simulent les échanges lumineux entre les primitives géométriques d’une scène à l’aide de
calculs par éléments finis.
5 Résultats 89
5.1.2 Statistiques
L’application la plus directe d’une requête de visibilité entre deux polygones est le calcul du PVS
d’une scène. Cependant, ce calcul demande des algorithmes de plus haut niveau pour organiser les
requêtes en exploitant la cohérence spatiale et éliminer les requêtes redondantes [96, 120]. Plutôt que
d’avoir recours à un algorithme de ce type, dont les performances sont fortement dépendantes du type
de scène, nous avons préféré évaluer les performances de la requête d’occultation au moyen d’une
procédure de test statistique. Cette procédure est la suivante. Pour chacune des scènes de test, des
cellules cubiques de taille identique ont été placées le long d’un chemin traversant la scène. Ensuite,
100 000 paires de boı̂tes englobantes furent sélectionnées, la première correspondant à l’une des cel-
lules et la seconde entourant un objet de la scène. La visibilité mutuelle de chaque paire de boı̂tes
fut ensuite déterminée à l’aide de requêtes d’occultation. Pour ce faire, chacune des deux boı̂tes fut
d’abord remplacée par un polygone représentant une approximation conservative de la boı̂te ; ce po-
lygone représente l’union de toutes les vues de la boı̂te depuis l’ensemble des points de l’autre boı̂te.
Une requête de visibilité fut ensuite appliquée entre les deux approximations, pour déterminer si elles
étaient masquées. Dans ce cas, cela signifie que les boı̂tes étaient également masquées, et le calcul
peut s’arrêter. Dans le cas contraire, la visibilité mutuelle des 36 paires de faces de ces deux boı̂tes
fut testée, et les boı̂tes ne furent déclarées masquées que si toutes les combinaisons de faces étaient
mutuellement masquées. Pour un traitement efficace, les scènes ont été stockées dans un <octree>, et
un algorithme de <shaft culling> a été utilisé pour limiter les tests d’intersection avec les objets situés
à l’intérieur de l’enveloppe convexe des deux boı̂tes englobantes [77]. Les résultats sont résumés dans
la Table 4.1.
% Découpes Droites Ecrans Extraction Temps

rep. effectifs Sil.(ms) (ms)
Visibles
a 8 (5.3) 0/7.5/169 1/7.5/151 0/8.1/148 0/0.2/22.8 0.2/4.3/112.7
b 16 (5.6) 0/19.3/2.4k 1/11.8/1.2k 0/16.8/642 0/0.2/21.7 0.2/10.7/1.5k
c 46.6 (32.3) 0/70.1/42.9k 1/34.7/20k 0/55.4/5k 0/1.3/394.4 0.3/62/56.4k
d 22.3 (17.7) 0/17.7/6.9k 1/11/3.6k 0/14.7/3k 0/17.2/7.9k 0.6/80.5/24.5k
Occultés
a 92 (94.7) 0/5.1/162 1/6.5/138 1/8.8/122 0/1.1/44.2 0.3/6.6/106.7
b 84 (94.4) 0/51.8/6.7k 1/32.6/3.6k 1/55.5/1.1k 0/1.5/78.3 0.3/34.5/5.4k
c 54.4 (67.7) 0/117.7/20.3k 1/60.6/9.8k 0/88.9/3k 0/2.8/335.3 0.4/113.3/30.5k
d 77.7 (82.3) 0/15.2/15.4k 1/8.9/8.1k 0/11.6/2.9k 0/36/10.4k 0.6/107.6/35.4k
TAB . 4.1: Pour chacune des scènes, 100 000 requ êtes aléatoires entre boı̂tes ont été réalisées. Pour chaque
mesure, nous donnons les valeurs minimum/moyenne/maximum que nous avons observ ées. La première colonne
donne le pourcentage de requ êtes visibles et le temps global passé pour les effectuer (entre parenthèses). Les
3 colonnes suivantes donnent respectivement le nombre de d écoupes, de droites représentatives, et d’écrans
effectifs utilisés pour chaque requête. La colonne <Ex. Sil.> donne le temps pass é pour extraire les silhouettes
étendues. Finalement, le temps total n écessaire pour réaliser une requête entre deux polygones est donn é dans
la colonne <Temps>.
(a) (b)
(c) (d)
F IG . 4.21: (a) Vienne (26k tri.). (b) Niveau 12 (115k tri.). (c) Niveau 1 (188k tri.). (d) Bonga (4.6Mo tri.).
5.1.3 Discussion
Etant donné le procédé de terminaison précoce, les distributions des requêtes de visibilité entre
polygones mutuellement visibles et mutuellement occultés sont sensiblement différentes, c’est pour-
quoi nous les avons présentées séparément.
Chaque requête commence par la création du polytope initial P . Lorsque S et R sont deux quadri-
latères, la méthode d’énumération de sommets [66] utilisée précédemment dans la littérature [120]
nécessiterait 8 10 3 sec., ce temps incluant le calcul du graphe d’incidence complet de P . Il s’agit
donc d’un sérieux goulet d’étranglement 21 . Dans la même situation, la méthode directe de construc-
tion que nous utilisons nécessite 24:5 10 6 sec, et est donc environ 300 fois plus rapide que la
méthode par énumération de sommets.
Pour améliorer les performances de notre algorithme, nous devons en identifier les goulets d’étrang-
lements. Dans ce but, nous avons mesuré le temps moyen passé dans chacune des parties de l’algo-
rithme. Les résultats sont présentés dans la Figure 4.22(a), en fonction du nombre d’écrans effective-
ment soustraits durant une requête, appelé le nombre d’écrans effectifs [120].
Comme on pouvait s’y attendre, les opérations les plus coûteuses sont les opérations de <CSG>
dans l’espace de Plücker et les intersections des droites représentatives avec la géométrie. Cette
21 La situation est même pire dans le cas de l’algorithme de Bittner [20], puisque l’algorithme de création du polytope
n’est pas utilisé une seule fois par requête, mais bien une fois pour chaque écran soustrait.
5 Résultats 91
1
0.2 10
Total
0.18
Extraction des silhouettes
«CSG» dans l’espace de Plücker
0.16
Intersection des droites rep. 0
10
0.14 Construction du polytope initial
Temps (sec)
Temps (sec)
0.12
−1
0.1 10
0.08
0.06
−2
10
0.04 Algorithme «classique»
Requête optimisée (Sans aggrégation)
0.02 Requête optimisée (Avec aggrégation)
−3
0 10
0 50 100 150 200 0 50 100 150 200
Nombre d’écrans effectifs Nombre d’écrans effectifs
(a) (b)
F IG . 4.22: Scène du <Niveau 12> (a) Agr égation des écrans basée sur la silhouette étendue : temps pour les
différentes étapes de l’algorithme en fonction du nombre d’ écrans effectifs. (b) Comparaison de l’algorithme
avec différentes méthodes de calcul exact.
dernière est considérablement plus coûteuse qu’un simple lancer de rayons, car les tests d’intersec-
tion ne peuvent pas être arrêtés après le premier objet touché. Avec une moyenne de 4000 droites
représentatives traitées par seconde, notre implémentation est beaucoup plus lente que les standards
actuels en lancer de rayons [159], et pourrait certainement être améliorée. Une autre possibilité se-
rait d’arrêter les tests d’intersection lorsqu’un nombre donné d’écrans a été rencontré. Notons que
le nombre de droites représentatives a déjà été réduit en les <recyclant> entre les polytopes générés
durant les découpes (cf. section 4.1).
Dans la majorité des cas, le temps nécessaire pour extraire les silhouettes est négligeable. En
fonction du type de scène, le temps moyen consacré à cette extraction varie entre 1 et 36 ms par
requête. Ce temps est très inférieur en comparaison à celui qui aurait été nécessaire pour effectuer
toutes les opérations de découpe. Notons cependant que dans certaines configurations difficiles, le
temps nécessaire pour extraire les silhouettes peut devenir moins négligeable (atteignant dans le pire
des cas 95% du temps de calcul total de la requête). Un algorithme de cache, similaire à celui utilisé
par Aila et al. [2] pourrait être utilisé pour limiter le coût des extractions de silhouettes (nous n’avons
pas implémenté cette optimisation).
5.1.4 Comparaison avec l’état de l’art

A des fins de comparaison, nous avons aussi implémenté la requête exacte de visibilité entre deux
polygones présentée dans [120], modifiée pour résoudre la fragmentation en éliminant les découpes
inutiles comme décrit en [113]. Les découpes sont donc éliminées après avoir été effectuées. Pour
permettre une comparaison directe, nous avons implémenté cette méthode en utilisant les algorithmes
basés sur le squelette des polytopes présentés à la section3, et le procédé de sélection d’écrans présenté
à la section 4.1. Malgré ces améliorations apportées à la méthode originale, nous nous référons à cette
implémentation comme étant l’algorithme <classique>. Outre la technique d’agrégation des écrans, la
différence principale entre l’algorithme classique et la requête de visibilité que nous avons présentée
à la section 4.3 réside dans le fait qu’une fois qu’un écran a été sélectionné, tous les polytopes du
complexe sont découpés par toutes les arêtes de son polytope dual (notre requête évitant ces découpes
inutiles).
Le temps nécessaire pour réaliser une requête en fonction du nombre d’écrans effectifs est donné à
la Figure 4.22(b), (pour la scène du <Niveau 12>). La courbe <classique> est la première courbe de la
Figure. Pour des requêtes suffisamment complexes, les résultats obtenus avec l’algorithme classique
sont compatibles avec ceux présentés dans [120]. Cependant, notre implémentation modifiée est plus
rapide pour les requêtes simples, car elle bénéficie de l’accélération de l’algorithme de création du po-
lytope initial. Pour l’ensemble des courbes de la Figure4.22(b), des modèles paramétriques, résultant
d’une approximation par la méthode des moindres carrés, fournissent une évaluation de la complexité
de l’algorithme. Nous avons mesuré une complexité de O(n1 84 ) pour l’algorithme classique, n étant
:
le nombre d’écrans effectifs.
La seconde courbe correspond à l’algorithme présenté à la section 4.3 utilisé sans le processus
d’agrégation des écrans, toutes les arêtes étant utilisées comme hyperplans de découpe. En comparai-
son à l’algorithme classique, les écrans ne sont utilisés que localement, et les découpes inutiles sont
éliminées avant d’avoir été effectuées. Pour 100 écrans effectifs, le nouvel algorithme est environ 5
fois plus rapide.
La dernière courbe correspond à notre algorithme complet, utilisé avec le procédé d’agrégation
des écrans. La plupart des découpes correspondant aux arêtes internes sont éliminées, et on observe
une accélération presque constante par rapport à la courbe précédente, de l’ordre de 6.
Pour 100 écrans effectifs, l’accélération entre l’algorithme classique et la requête complète, utilisant le
procédé d’agrégation des écrans, est donc de l’ordre de 30. La complexité de la courbe avec agrégation
est de O(n1 44 ).
:
5.2 Sélection des écrans et détection des ouvertures

Pour étudier le comportement de l’algorithme pour la sélection des écrans et la détection des
ouvertures, nous avons réalisé l’expérience suivante, basée sur une scène synthétique. Nous avons
choisi deux triangles équilatéraux de taille identique pour jouer le rôle des polygones S et R, et nous
les avons placés parallèlement l’un par rapport à l’autre. Nous avons ensuite inséré des écrans de
manière incrémentale entre ces deux polygones, chaque écran étant lui-même un triangle équilatéral
dont la taille est choisie de manière aléatoire(cf. Figure4.23).
F IG . 4.23: Expérience des écrans aléatoires : des triangles équilatéraux de position et de taille al éatoires
sont insérés de manière itérative entre les deux polygones S et R. La droite en pointill é représente une droite
représentative ne rencontrant aucun écran.
5 Résultats 93
Après l’ajout de chaque écran, nous évaluons la visibilité mutuelle de S et de R, à l’aide d’une
requête de visibilité. Etant donné que les écrans ne font pas partie de maillages (c-à-d que chaque
écran est un triangle isolé), il n’est pas possible d’utiliser le processus d’agrégation d’écrans basé sur
la silhouette étendue, qui est donc désactivé. Nous avons reproduit cette expérience 1000 fois, et les
résultats sont présentés dans la Figure 4.24(a).
5
60 10
Nombre moyens de rayons aléatoires (p)

4
50 10
3
40 10
Nombre moyen
2
30 10
1
20 10
10 Droites représentatives 0
10
Ecrans effectifs
Opérations de découpe
−1
0 10
0 100 200 300 400 500 600 700 800 0 50 100 150 200 250 300 350
Nombre d’écrans Nombre d’écrans
(a) (b)
F IG . 4.24: Expérience des triangles aléatoires. (a) Les nombres de droites représentatives, de découpes et
d’écrans effectifs pour l’expérience des triangles aléatoires. (b) Le nombre moyen p de rayons al éatoires
nécessaires pour découvrir une ouverture, en fonction du nombre d’ écrans présents entre S et R dans
l’expérience des écrans aléatoires.
Comme on peut le constater, les courbes sont clairement décomposées en deux phases : une
phase <visible> et une phase <occultée>. Pendant la phase <visible>, les courbes augmentent avec
le nombre d’écrans. Les deux polygones S et R deviennent de moins en moins visibles, et la ter-
minaison précoce est retardée au fur et à mesure du rétrécissement des ouvertures. Les courbes at-
teignent un maximum quand les deux polygones deviennent mutuellement masqués, avec 310 écrans
en moyenne, suite à quoi elles passent dans la phase <occultée>. Dès ce moment, l’ajout de nouveaux
triangles donne plus de choix pour la sélection des écrans, et les courbes commencent à descendre.
Cela montre que le coût de la requête n’est pas proportionnel au nombre d’écrans présents entre S
et R. Dès que les polygones sont occultés, l’ajout d’écrans a même un effet positif sur le temps de
calcul22 .
En cas de visibilité mutuelle, la terminaison précoce des requêtes était obtenue dans les travaux
précédents en testant s’il existait un rayon libre parmi un ensemble de rayons choisis de manière
aléatoire entre S et R [120]. Lorsqu’aucun des rayons choisis de manière aléatoire ne traversait une
ouverture, tous les écrans devaient être soustraits avant de pouvoir établir la visibilité mutuelle. Les
requêtes <visibles> étaient donc potentiellement plus coûteuses que les requêtes <masquées>, puisque
ces dernières ne nécessitaient que la soustraction du sous-ensemble d’écrans nécessaires pour prouver
l’occultation. Soit p le nombre moyen de rayons aléatoires nécessaires pour découvrir une ouverture.
22 Sauf pour les tests d’intersection entre les droites représentatives et la géométrie qui sont de plus en plus coûteuses.
La Figure 4.24(b) donne p en fonction du nombre d’écrans présents entre S et R23 . Ce nombre devient
très grand (de l’ordre de 104 ) dès que la taille des ouvertures décroı̂t. Au contraire, notre procédé de
détection des ouvertures guidé par la visibilité détermine la visibilité mutuelle avec un nombre borné
de droites représentatives, de l’ordre de 15. En utilisant notre algorithme, le besoin de soustraire tous
les écrans présents entre les deux polygones est totalement éliminé.
6 Conclusion et perspectives
Dans ce chapitre, nous avons présenté, implémenté et validé un nouvel algorithme permettant
d’effectuer de manière analytique une requête d’occultation entre deux polygones.
Dans les méthodes précédentes, les opérations de découpe étaient réalisées à l’aide du graphe
d’incidence complet des polytopes, ce qui revenait à construire un sous-ensemble localisé du com-
plexe de visibilité [55]. Notre approche utilise uniquement le 1-squelette des polytopes, et est, de ce
fait, proche de la construction d’un sous-ensemble du squelette de visibilité [56]. D’un point de vue
conceptuel, notre approche est donc similaire à l’introduction du squelette de visibilité pour les calculs
globaux d’illumination, à la place du complexe de visibilité. Cette comparaison n’est pas entièrement
correcte, car le 1-squelette des polytopes contient une information différente du squelette de visibilité.
Ce dernier encode les surfaces critiques (c-à-d les surfaces délimitant les discontinuités de visibilité)
et les droites poignardantes extrêmes, alors que le 1-squelette n’encode explicitement que les droites
poignardantes extrêmes (cf. Figure 4.25). Cependant, ces dernières sont toujours groupées en poly-
topes, qui correspondent aux cellules de dimension supérieure du complexe de visibilité : ce dernier
peut donc toujours être reconstruit à partir du 1-squelette.
F IG . 4.25: Comparaison entre le squelette de visibilité et le 1-squelette d’un polytope (sch éma de principe)
(a) Squelette de visibilité : les nœuds du graphe sont les droites poignardantes extr êmes si , les arcs sont les
surfaces critiques Ci . (b) 1-squelette : les nœuds contiennent les sommets Vi du polytope, les arcs contiennent
ses arêtes E [Vi ; V j ]. Les intersections de certaines arêtes avec la quadrique de Pl ücker sont les points Si , qui
correspondent dans l’espace primal aux droites poignardantes extr êmes si (les surfaces critiques ne sont donc
pas représentées explicitement).
Le premier bénéfice de l’algorithme que nous avons proposé est de réduire la complexité moyenne
des requêtes, en choisissant les écrans localement pour chacun des polytopes : les découpes inutiles
23 Chaque point de cette courbe a été déterminé en lançant un nombre important de rayons de manière aléatoire, et en
mesurant la proportion de rayons bloqués par les écrans.

6 Conclusion et perspectives 95
sont éliminées. De plus, les chances de terminaison précoce sont augmentées dans le cas de la visibi-
lité mutuelle, puisque des rayons sont lancés dans chaque ouverture laissée par les écrans déjà traités.
Notre algorithme de lancer de rayons est relativement lent en comparaison des standards actuels et
constitue un goulet d’étranglement dans les scènes complexes. Il serait donc possible de l’optimiser
pour améliorer le temps de calcul des requêtes d’occultation.
Lorsque notre algorithme est utilisé avec le procédé d’agrégation des écrans, son temps d’exécution
devient sensible à la complexité de la silhouette étendue des écrans, plutôt qu’à la complexité de
leur maillage complet. Les désavantages de ce procédé d’agrégation sont liés à l’extraction des sil-
houettes : les relations d’adjacence entre les triangles doivent être stockées pour chaque maillage, et
les silhouettes doivent être extraites pour chaque requête. Cependant, le temps nécessaire pour effec-
tuer cette tâche est faible en comparaison du temps qui aurait été nécessaire pour réaliser toutes les
opérations de découpe, et le coût mémoire nécessaire à leur stockage est réduit.
Dans l’implémentation que nous avons proposée, les silhouettes étendues sont extraites de manière
globale par rapport aux polygones S et R. Les silhouettes obtenues sont donc indépendantes du poly-
tope Pi que l’algorithme est en train de traiter. Pourtant, au fur et à mesure des soustractions de droites
bloquées, les polytopes représentent des ensembles de droites de plus en plus <fins> : il serait possible
d’en tirer parti, en extrayant les silhouettes de manière locale pour chaque polytope. Dans le même
ordre d’idée, il serait intéressant de développer un test exact pour déterminer si e divise effectivement
l’ensemble des droites à l’intérieur de chaque polytope Pi afin de remplacer le test conservatif basé
sur l’enveloppe convexe de S et R que nous utilisons et de diminuer le nombre de découpes inutiles.
Le problème de la sélection des écrans est NP-complet, car il se ramène au problème classique
de couverture d’ensemble (cf. ouvrage de Cormen et al. [41] page 997). Pour le résoudre, nous avons
développé une heuristique de sélection gloutonne, basée sur un décompte des droites représentatives
qui rencontrent chacun des écrans. Cette approche ne fournit pas toujours le meilleur ordonnancement
des écrans [120], en particulier lorsque les écrans sont composés de polygones de taille similaire, et
nous aimerions améliorer cette heuristique dans le futur.
Comme tous les algorithmes de géométrie algorithmique exécutés sur des unités de calcul en
virgules flottantes, notre implémentation souffre des problèmes d’imprécision numérique. Pour y
remédier, nous avons utilisé une représentation des nombres en double précision et avons utilisé le
procédé classique de comparaison des nombres à un <ε près>. Bien qu’elle fonctionne dans la grande
majorité des cas, cette stratégie est prise en défaut dans certaines configurations géométriques par-
ticulières. Une solution pourrait être d’effectuer les calculs à l’aide d’une librairie d’arithmétique
exacte [168] ou d’arithmétique à précision variable, lorsque la précision de l’implémentation en vir-
gule flottante standard est prise en défaut.
Finalement, il va sans dire que nous aimerions incorporer notre mécanisme de requête de visibi-
lité dans un algorithme complet de calcul de <PVS>, tel que celui présenté récemment par Samuli
Laine [96]. Une voie très prometteuse consisterait à combiner l’algorithme exact à un algorithme
conservatif, comme proposé récemment par Bittner et al. dans le cas 2D12 [19]. La majorité du <PVS>
serait alors calculée à l’aide de l’algorithme conservatif, beaucoup plus rapide que l’algorithme exact,
qui ne serait utilisé qu’en dernier recours pour résoudre les cas difficiles.
P r é c a l c u l d e v i s i b i l i t é d e p u i s l e s
chapitre 5
objets
Sommaire
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
1.1 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
1.2 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.1 Visibilité encodée au niveau des objets . . . . . . . . . . . . . . . . . . . . 99
2.2 Ecrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
3 Principe de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.1 Représentation des volumes d’ombre . . . . . . . . . . . . . . . . . . . . 101
4.2 Choix des écrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.3 Calcul de visibilité en ligne . . . . . . . . . . . . . . . . . . . . . . . . . 105
5 Compression de l’information . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6 Résultats et discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.1 Description des scènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
6.2 Evaluation de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.3 Comparaison avec des PVS . . . . . . . . . . . . . . . . . . . . . . . . . 113
7 Conclusion et travail futur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.1 Ecrans virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.2 Encodage hiérarchique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.3 Application au calcul de <PVS> . . . . . . . . . . . . . . . . . . . . . . . 119
1 Introduction
Comme nous l’avons vu dans le chapitre 3, le précalcul complet et exact de la visibilité en 3D est
hors de portée dans le domaine de l’<occlusion culling>, car un tel précalcul nécessite une algorith-
mique sophistiquée, qui est trop coûteuse pour espérer obtenir des accélérations du temps d’affichage.
En pratique, des solutions plus simples sont donc utilisées, telles que les méthodes de <PVS> ou de
graphes cellules-portails.
98 chapitre 5. Précalcul de visibilité depuis les objets
Les méthodes de PVS consistent à découper l’espace en régions, et à associer à chaque région la
liste des primitives visibles. Ces techniques sont attractives, car elles s’adaptent à tout type de scène
et ne nécessitent que très peu de puissance de calcul durant la phase d’exploration interactive. Ce-
pendant, elles introduisent différents facteurs de sur-conservativité, qui se traduisent par l’affichage
inutile d’objets masqués : la sur-conservativité due à la méthode d’une part, qui survient lorsque l’on
utilise une méthode conservative pour calculer la visibilité, et la sur-conservativité due à la partition
d’autre part, qui survient lorsque les cellules utilisées pour calculer le PVS ne sont pas placées conve-
nablement, la visibilité depuis un point étant assimilée à la visibilité depuis une région (cf. page 46).
Nous avons présenté dans le chapitre 4 une requête exacte de visibilité entre deux polygones,
qui peut être utilisée pour calculer de manière exacte le PVS d’une région, et élimine de la sorte
entièrement la sur-conservativité due à la méthode. Dans ce chapitre, nous allons étudier une méthode
permettant de réduire la sur-conservativité due à la partition. Cette dernière se marque surtout dans
les environnements peu occultés : les objets n’étant masqués que depuis des régions très réduites,
les cellules doivent être placées avec soin pour parvenir à capturer les occultations. Pour éliminer
entièrement ce facteur de sur-conservativité, il serait nécessaire de découper l’espace navigable en
cellules de visibilité constante [128] :
– les cellules sont délimitées par l’ensemble des surfaces critiques de la scène.
– l’ensemble des objets visibles depuis tous les points d’une cellule est identique, de sorte que
les apparitions et disparitions d’objets lors de la navigation interactive ne surviennent que si
l’utilisateur change de cellule.
Créer une telle partition est envisageable en 2D, car les analogues des surfaces de visibilité sont
des droites et les régions de visibilité constante sont des polygones dont il est possible de déterminer la
forme exacte. Malheureusement, cela semble difficile pour des scènes complexes tridimensionnelles
car les difficultés soulevées sont nombreuses. Pour commencer, les surfaces critiques qui délimitent
les régions de visibilité constante sont des quadriques réglées, et il en existe potentiellement beaucoup
(O(n3 )). Dès lors, créer une partition optimale consisterait à calculer les régions délimitées par ces
surfaces, ou en d’autres termes, à calculer un arrangement de surfaces du second ordre. Les surfaces
critiques <s’arrêtant> lorsqu’elles rencontrent un polygone opaque de la scène, ce calcul d’arrange-
ment devrait être réalisé en tenant compte des occultations. Toujours en raison des occultations, seul
un sous-ensemble de cet arrangement devrait être conservé, les cellules de l’arrangement dont les
frontières ne correspondraient pas à des événements de visibilité étant éliminées. Finalement, une
contrainte supplémentaire rendrait cet arrangement caduc : la localisation de la caméra au sein de la
partition serait très difficile à réaliser si l’on utilisait ce sous-ensemble de l’arrangement des surfaces
critiques de la scène. A cause de ces difficultés, aucune partition en cellules de visibilité constante n’a
jamais été calculée à notre connaissance. Des partitions approchées leur sont préférées en pratique (cf.
page 55), et ce sont ces dernières qui sont à l’origine de la sur-conservativité due à la partition.
Outre ce problème de conservativité, le modèle du PVS précalculé présente un autre inconvénient :
l’espace navigable, dans lequel l’utilisateur est susceptible de se déplacer, doit être pavé de cellules :
il faut donc qu’il soit de dimension finie ; de plus, il est nécessaire qu’il soit connu à l’avance. Un
problème de temps de calcul et de coût de stockage apparaı̂t, puisque le PVS de chacune des cellules
doit être déterminé et stocké même pour des cellules où l’utilisateur a très peu de chance de se rendre.
Dans ce chapitre, nous proposons une solution alternative au modèle du PVS pour stocker la
visibilité et accélérer l’affichage de scènes 3D. Nous abandonnons l’idée d’une partition de l’espace
navigable en cellules, et associons à chaque objet de la scène l’information nécessaire pour déterminer
s’il est occulté depuis n’importe quel point P de R3 . Le premier objectif est de déterminer si cette solu-
tion permet de réduire les inconvénients du PVS que nous venons de décrire. Le second est d’évaluer
son coût d’utilisation, pour vérifier qu’il permet effectivement d’accélérer l’affichage au cours d’un
scénario de navigation interactive.
Remarque : Ces travaux ont été réalisés en collaboration avec Xavier Décoret.
1.1 Contributions
Nous introduisons l’idée d’encoder l’information de visibilité au niveau des objets, pour remplacer
l’encodage classique de visibilité à l’aide de PVS stockés au niveau des cellules. Nous proposons
de représenter cette information à l’aide d’écrans virtuels originaux, appelés <capsules>, permettant
de traiter les scènes à faible complexité verticale. Nous montrons ensuite que ces écrans peuvent
être utilisés pour effectuer des requêtes de visibilité tout en exploitant la cohérence temporelle. Nous
donnons finalement un algorithme permettant de compresser l’information de visibilité stockée au
niveau des objets.

La section 2 présente un bref état de l’art consacré aux techniques de visibilité ayant un rapport
direct avec la méthode proposée. Nous décrivons le principe de cette dernière dans la section3, puis en
proposons une implémentation dans la section 4. Un algorithme permettant de compresser l’informa-
tion de visibilité est proposé dans la section5. Les résultats sont présentés et discutés dans la section6.
Nous apportons finalement les conclusions et donnons différentes perspectives de développements fu-
turs dans la section 7.
2 Etat de l’art
2.1 Visibilité encodée au niveau des objets
L’idée d’encoder une information de visibilité au niveau des objets a été exploitée par James
Stewart dans le cas de l’affichage de terrains, définis sous la forme de champs de hauteurs [147].
En chacun des quadrilatères définissant sa surface, une représentation de l’horizon, tel qu’il est vu
depuis le quadrilatère, est calculée et stockée. Cet horizon sert à déterminer les portions de terrain
occultées lors de l’affichage. La représentation décrite par l’auteur est hiérarchique : les horizons de
différents quadrilatères peuvent être combinés, pour générer un horizon valable pour l’ensemble des
quadrilatères. Dès lors, de larges portions de terrain masquées peuvent être détectées à l’aide d’un seul
test.
Dans le cadre de la compression de PVS, Zach et al. proposent de stocker la liste des cellules visibles
associées à chaque objet, à la place de stocker la liste des objets associés à chaque cellule [170]. Le but
recherché est d’obtenir de meilleurs taux de compression en exploitant la cohérence de l’information
de visibilité de manière plus efficace.
2.2 Ecrans virtuels

Nous renvoyons le lecteur à la page 52 pour un état de l’art sur les écrans virtuels utilisés pour
représenter la visibilité depuis une région R. Nous avons utilisé dans ce chapitre des écrans virtuels
proches des <GOM> [86]. Pour rappel, les <GOM> sont des cubes, formés par 6 images disposées
autour de R ; chaque pixel (i; j) d’une image du <GOM> correspond à une <barrière virtuelle> po-
lygonale Bi j dans R3 . La couleur du pixel (i; j) indique la plus petite distance à laquelle la barrière
Bi j peut être placée, de telle sorte que le polygone Bi j soit invisible depuis n’importe quel point de
R. L’ensemble des barrières virtuelles ainsi positionnées peuvent être utilisées comme écrans virtuels,
à la place de la géométrie de la scène, pour déterminer les objets masqués depuis R. Un <GOM>
encode une approximation de l’ombre générée par la région R remplacée par une source lumineuse,
correspondant à l’ombre infinie générée par les barrières virtuelles.
3 Principe de la méthode
Soit une scène composée d’un ensemble d’objets, et soit Ui l’ombre que générerait l’un de ces ob-
jets Oi s’il était remplacé par une source lumineuse et s’il éclairait le reste de la scène1 . Au cours d’une
phase de précalcul, chaque objet Oi est considéré tour à tour et son ombre Ui est calculée et stockée.
Au cours de la phase de navigation interactive, chacun des objets Oi est <interrogé> avant d’être af-
fiché pour savoir s’il est visible : l’objet <répond> en testant si la caméra est située dans l’ombre Ui
qui lui est associée. Cette méthode peut être vue comme une application du principe de superposition,
utilisé en physique pour décomposer un phénomène complexe en plusieurs phénomènes plus simples.
Par exemple en électricité, il permet de calculer le courant et la tension dans un circuit électrique, en
considérant successivement chacune des sources et en désactivant les autres. On somme ensuite toutes
les composantes calculées (cf. Figure 5.1)2 . Un autre exemple est celui de la décomposition d’un si-
gnal périodique en une somme de signaux de différentes fréquences, à l’aide de séries de Fourier.
(a) (b) (c) (d)
F IG . 5.1: Principe de superposition des sources en électricité. (a)(b)(c) Chaque source de courant ou de tension
est considérée successivement, alors que les autres sont désactivées, les sources de tension étant remplacées par
un court-circuit et les sources de courant par un circuit ouvert. (d) R ésultat complet, obtenu par superposition
des différentes solutions : I1 = I1a + I1b + I1c ; I2 = I2a + I2b + I2c ; I2 = I2a + I2b + I2c ; U = Ua + Ub + Uc .
Comme on le constate sur la Figure 5.2, la superposition de toutes les ombres Ui est équivalente
à une partition en cellules de visibilité constante. Cette décomposition du problème permet donc en
théorie d’éliminer entièrement la sur-conservativité due à la partition et d’obtenir un stockage de la
visibilité optimum, équivalent à la partition en cellules de visibilité constante, ce résultat étant obtenu
à l’aide du calcul -comparativement plus simple- de l’ombre générée par chacun des objets remplacé
par une source lumineuse.
Nous présentons dans la section suivante une mise en œuvre pratique de ce principe.
1 Nous ne faisons pas de distinction entre l’ombre générée par un seul objet, et l’ombre créée par la fusion des pénombres
de plusieurs objets.
2 Ce principe de superposition n’est valide que si le circuit électrique est composé d’éléments linéaires.
4 Mise en œuvre 101
(a) (b) (c) (d)
(e)
F IG . 5.2: Principe de superposition. (a)(b)(c)(d) Ombre U i générée par chacun des objets O i remplacé par
une source lumineuse. (e) La superposition des solutions est équivalente à une partition en cellules de visibilit é
constante.
4 Mise en œuvre
4.1 Représentation des volumes d’ombre
Lors de la présentation générale de la méthode, nous avons implicitement fait la supposition que
les volumes d’ombre Ui étaient encodés de manière exacte. C’est en effet à cette seule condition que la
sur-conservativité est entièrement éliminée, et que le stockage est équivalent à la partition en cellules
de visibilité constante. Mais en pratique, un encodage exact semble difficile à obtenir. D’une part car
les volumes d’ombre Ui ne sont pas simples à représenter :
– ils sont délimités par les surfaces critiques (c-à-d des morceaux de quadriques réglées qui s’in-
terpénètrent)
– ils sont non-connexes et non-convexes dans la majorité des cas
– il faut tenir compte de la fusion des pénombres pour les obtenir
D’autre part, car la structure de données choisie pour représenter les ombres doit permettre d’effectuer
les requêtes de visibilité de manière très efficace. En effet, l’objectif de notre travail est d’accélérer
la navigation interactive, et il est donc nécessaire que l’élimination des objets masqués puissent être
effectuée de manière plus rapide que leur affichage. Il serait par exemple possible d’envisager d’en-
coder les ombres de manière exacte à l’aide d’une technique semblable à celle proposée par Jiřı́ Bitt-
ner [20] : les volumes d’ombre seraient alors représentés sous forme d’arbres <BSP> dans l’espace
dual de Plücker. Cette approche nécessiterait d’encoder une information de profondeur additionnelle,
car cette dernière ne peut être représentée dans l’espace de Plücker [20] 3 . Mais cette approche ne
résiste pas à l’analyse :
3 Jiřı́ Bittner contourne cette difficulté en traitant les primitives géométriques de la scène par ordre de profondeur crois-
sant, et en construisant de manière incrémentale un volume d’ombre qui n’est valable que pour les primitives géométriques
situées derrière le dernier écran rencontré.
– elle nécessiterait des besoins en mémoire importants [20], ce qui réduirait l’intérêt de la méthode
par rapport à un PVS
– étant donné sa complexité, elle ne permettrait pas d’effectuer les requêtes de visibilité de
manière suffisamment efficace pour accélérer la navigation interactive.
Pour répondre à l’ensemble des contraintes exposées ci-dessus, nous avons préféré encoder les ombres
de manière approchée, et avons choisi de les représenter directement dans l’espace euclidien R3 , sous
la forme d’écrans virtuels [94]. Les ombres sont encodées de manière prudente, c’est-à-dire qu’elles
peuvent éventuellement être sous-estimées mais ne seront jamais surestimées. Nous acceptons donc
l’affichage éventuel d’objets masqués, qui se traduira par un facteur de sur-conservativité.
4.2 Choix des écrans virtuels

A chaque objet Oi est associé un ensemble d’écrans virtuels, qui encodent une approximation
conservative discrète de l’ombre Ui . Dès lors, ce sont ces écrans virtuels qui déterminent entièrement
la qualité de l’approximation ainsi que le coût des requêtes de visibilité. Nous avons utilisé des écrans
virtuels semblables aux <GOM> [86]. Les <GOM> étant fortement anisotropes 4 , nous avons décidé
de ne pas les utiliser tels quels, et avons préféré utiliser des écrans virtuels couvrant l’ensemble des
directions de manière isotrope. Dans un premier temps, nous avons utilisé des barrières virtuelles
disposées selon un encodage radial pur : pour chaque objet Oi , le centre C de sa plus petite sphère
englobante est calculé. Nous découpons ensuite la sphère des directions en un nombre fini de secteurs
si . Une barrière virtuelle Bi est associée à chaque secteur si ; chaque barrière est tangente à une sphère
de centre C, et est placée à une certaine distance choisie de telle sorte que l’ombre générée par la
barrière virtuelle Bi soit incluse dans l’ombre exacte Ui . Nous l’appelons distance frontière du secteur
si , et la notons di (cf. Figure 5.3). S’il n’est pas possible de placer la barrière virtuelle Bi pour que
l’ombre générée soit correcte, nous choisissons di = 1.
F IG . 5.3: Encodage radial des écrans virtuels en 2D.
Les secteurs pourraient être obtenus en quantifiant les angles d’Euler, mais cette approche aug-
menterait la densité de secteurs au niveau des pôles, au détriment des secteurs proches de l’équateur.
4 Les barrières sont encodées dans des images formant un cube aligné par rapport aux axes de la scène, et les barrières
sont donc elles aussi parallèles aux axes.
Pour obtenir une subdivision de secteurs uniforme, nous avons choisi de subdiviser un octaèdre5 de
manière régulière : chaque face de l’octaèdre est subdivisée de manière récursive en quatre triangles
équilatéraux, jusqu’à ce qu’un niveau de subdivision donné soit atteint. Cet encodage radial capture
une large part de l’ombre Ui , mais il ne permet pas de représenter certaines régions importantes,
car il ne capture que les ombres radialement infinies depuis le centre de l’objet (cf. Figure5.4 (a)).
Mais dans de nombreuses scènes, la visibilité est fortement anisotrope : en raison de la pesanteur, les
hadow
True S
hadow
True S
ding
co
capsule en
ing adow
red sh Captured shadow
od Captu
c
radial en
object
object
(a) (b)
F IG . 5.4: (a) Un exemple d’ombre infinie qui ne peut pas être capturée radialement depuis le centre de l’ob-
jet. (b) L’encodage à l’aide d’une capsule capture plus de l’ombre pr ésente dans la direction verticale que
l’encodage radial.
scènes s’étendent principalement dans le plan horizontal, et leur complexité verticale est réduite 1[ 02].
L’ombre Ui générée par un objet occupe effectivement dans ce cas de larges angles solides dans le
plan horizontal, mais ce n’est pas le cas dans le plan vertical. Nous avons observé ce comportement
dans l’ensemble de nos scènes de test, c’est pourquoi nous avons développé un nouveau système
d’écrans virtuels, appelés capsules, pour tenter de mieux approcher les ombres. Une capsule est un
cylindre vertical fermé par deux demi-hémisphères, le cylindre contenant entièrement l’objet. L’es-
pace situé au-dessus et en dessous du cylindre est divisé en secteurs en subdivisant les hémisphères
comme précédemment. Les secteurs correspondant à la partie cylindrique sont obtenus en quanti-
fiant un système de coordonnées cylindriques : le secteur si est défini par z 2 [zi ; zi+1 ]; θ 2 [θi ; θi+1 ]
(cf. Figure 5.5). La Figure 5.4 montre pourquoi une capsule permet d’approcher l’ombre exacte avec
moins de perte que l’encodage radial. Cette idée de découpler les directions horizontales et verti-
cales a d’ailleurs été récemment exploitée par Leyvand et al. pour calculer la visibilité depuis une
région [102].
Bou
r nda
cto ry c
Se ap
zi+1
θ i+1
zi θi
F IG . 5.5: Un secteur de la partie cylindrique de la capsule.
Tout comme nous approchions la subdivision radiale en subdivisant un octaèdre, nous définissons
les secteurs des capsules en subdivisant de manière récursive un polyèdre. Le cylindre de la cap-
5 L’octaèdre est le solide platonicien formé par huit triangles équilatéraux égaux.
sule est approché par la subdivision régulière des faces rectangulaires d’une boı̂te verticale à section
carrée. Les hémisphères au-dessus et en dessous du cylindre sont obtenus par la subdivision régulière
des faces d’une pyramide à base carrée. La Figure 5.6(a) montre le polyèdre initial comportant 12
faces : 4 triangles pour l’hémisphère supérieur, 4 triangles pour l’hémisphère inférieur et 4 rectangles
pour le cylindre. Les faces triangulaires et rectangulaires sont découpées en 4 faces égales, en ajou-
tant de nouveaux sommets à la surface de la capsule. La Figure 5.6(b) montre un exemple de ces
subdivisions. Notons que les résolutions des hémisphères et du cylindre sont indépendantes et qu’il
n’existe pas nécessairement de continuité à leur frontière (cf. par exemple le bas de la capsule dans la
Figure 5.6(b)).
(a) (b) (c)
F IG . 5.6: La subdivision récursive de la capsule en secteurs : à partir du polyèdre initial à 12 faces, nous
subdivisons récursivement les faces triangulaires (respectivement rectangulaires) en 4 triangles (respectivement
rectangles). Des sommets sont ajoutés au mileu des côtés et placés à la surface de la capsule.
Nous représentons l’historique des subdivisions récursives à l’aide d’arbres quaternaires, représen-
tant la subdivision de chacun des secteurs en quatre sous-secteurs. La capsule complète contient 12
arbres quaternaires, chacun d’entre eux décrivant la subdivision d’une des faces du polyèdre initial.
4.2.1 Précalcul de visibilité

Le précalcul de visibilité consiste à calculer pour chaque objet Oi les positions des barrières vir-
tuelles B j associées à chacun des secteurs sj . Ces positions sont déterminées de manière univoque par
la distance frontière d j , et c’est donc cette dernière qu’il s’agit de déterminer. Soit q(S; R) une requête
de visibilité, permettant de déterminer si les deux régions de l’espace S et R sont mutuellement vi-
sibles. Nous considérons ici que cette requête est une <boı̂te noire> mais nous la détaillons dans le
paragraphe suivant. Pour trouver la distance frontière dj à laquelle la barrière B j doit être placée, nous
effectuons un ensemble de requêtes q(Oi ; R j (d )), dans laquelle R j (d ) représente la partie semi-infinie
du secteur s j située derrière la barrière Bj positionnée à la distance d. La distance frontière dj cor-
respond à la plus petite distance d telle que Rj (d j ) soit entièrement masquée depuis tous les points
de la surface de l’objet Oi (cf. Figure 5.7). Pour plus d’efficacité, nous avons restreint les positions
possibles pour une barrière à N distances prédéfinies, et nous recherchons la première distance telle
que R j (d ) soit masqué à l’aide d’une recherche dichotomique.
Remarque : Ces distances sont fixées pour la scène et sont identiques pour tous les objets. Nous
avons utilisé une distribution quadratique des distances afin d’avoir plus de granularité près des ob-
jets.
F IG . 5.7: R j (d ) est la partie semi-infinie du secteur s j . La distance frontière d j associée au secteur s j est telle
que R j (d j ) est entièrement masquée depuis tout point de O i .
4.2.1.1 Requête de visibilité q(S; R) Lors de la réalisation des travaux présentés dans ce chapitre,
nous n’avions pas encore développé la requête de visibilité présentée dans le chapitre4, qui permet
de déterminer de manière exacte si deux polygones S et R sont mutuellement visibles. Puisqu’aucune
implémentation de requête de visibilité n’était disponible, nous avons utilisé à défaut une technique
beaucoup plus simple à mettre en œuvre, basée sur un échantillonnage aléatoire et semblable aux
techniques de visibilité agressives utilisant la méthode de l’<item buffer> [162] (cf. page 53).
Cet algorithme est le suivant. Nous choisissons de manière aléatoire un ensemble de points d’échan-
tillonnage sur la surface de l’objet Oi . En chacun de ces points, nous plaçons une caméra et dessinons
6 images de la scène, disposées en cube afin de couvrir l’ensemble des directions. Pour chaque sec-
teur si , nous construisons N polyèdres, représentant les volumes Ri (d j ) pour j 2 1::N. Nous comptons
ensuite le nombre de pixels de chacun de ces polyèdres visible dans les images de la scène. Nous
choisissons comme distance frontière di la distance du polyèdre Ri (di ) masqué le plus proche. Une
procédure dichotomique est utilisée, afin de tester la visibilité de log2 (N ) polyèdres uniquement.
Nous sommes conscient qu’un échantillonnage de ce type sous-estime la visibilité et introduit

des erreurs d’affichage, puisque certains objets visibles ne sont pas affichés. Il offre cependant les
avantages de ne jamais surestimer le PVS (c-à-d de n’introduire aucune sur-conservativité due à la
méthode) et d’offrir une grande rapidité d’exécution. De plus, le résultat converge rapidement vers
la solution exacte, et un nombre restreint de points d’échantillonnage donne déjà un très faible taux
d’erreur [119]. En comparaison, l’utilisation de la requête de visibilité exacte nécessiterait un temps
de calcul beaucoup plus important pour un final similaire du point de vue statistique, c’est pourquoi
nous avons conservé la solution basée sur l’échantillonnage aléatoire.
4.3 Calcul de visibilité en ligne

A la fin du précalcul, un ensemble d’écrans virtuels est associé à chacun des objets de la scène.
Durant la phase d’exploration interactive, ces écrans sont utilisés pour déterminer les objets visibles.
Soit un objet Oi dont on veut déterminer la visibilité depuis le point de vue courant E. La première
étape consiste à déterminer le secteur sj de Ui contenant E, à l’aide d’une étape de localisation.
Ensuite, la visibilité est déterminée en testant la position du point E par rapport à la barrière Bj :
l’objet est masqué si E est situé derrière cette barrière.
4.3.1 Localisation de la caméra au sein de la capsule

Soit C le centre de l’objet Oi . Le processus de localisation commence par calculer le vecteur
CE = CEx 1x + CEy 1y + CEz 1z . La composante verticale CEz indique dans quelle partie de la capsule
E est situé (dans la partie cylindrique ou dans l’un des deux hémisphères) comme montré à la Fi-
gure 5.8(a). Les signes des composantes horizontales CEx et CEy permettent ensuite de déterminer
le quadrant horizontal contenant E. L’arbre quaternaire qu’il faut parcourir pour trouver le secteur
<feuille> contenant E est donc connu ; dans l’exemple décrit dans la Figure 5.8(b), il s’agit de l’arbre
correspondant au secteur S3 .
y
S1 S2
C
C S11
E S112
S1121
E
S4 S3
x
S12
(a) (b) (c)
F IG . 5.8: Procédure de localisation de la cam éra. (a) Test de CEz pour savoir si E est situé dans un des secteurs
du cylindre ou dans un des secteurs des h émisphères. (b) Calcul du quadrant initial dans lequel se situe E à
l’aide de CEx et CEy . (c) Descente récursive de secteur en secteurs enfants, jusqu’au secteur feuille.
Chacun des secteurs correspondant à un nœud de l’arbre quaternaire contient les équations des
plans qui le subdivisent en sous-secteurs. Les produits scalaires entre les normales de ces plans et le
vecteur CE indiquent dans quel sous-secteur E est situé : cette recherche est répétée de secteur en
sous-secteurs, jusqu’à ce qu’un secteur feuille sf soit atteint (cf. Figure 5.8(c)). La comparaison de la
distance frontière d f avec la norme jjCE jj indique si le point est situé devant ou derrière la barrière
B f , et permet de savoir si l’objet est visible ou non depuis le point E.
4.3.2 Cohérence temporelle

Beaucoup de méthodes d’<occlusion culling> en ligne exploitent la cohérence temporelle pour
accélérer l’élimination des objets masqués [40, 21, 166]. Nous nous en sommes inspiré pour réduire
le nombre d’étapes de localisation à effectuer lors des déplacements de la caméra. Lorsque la visibi-
lité d’un objet est déterminée depuis un point de vue courant E, le résultat est stocké en vue d’une
réutilisation ultérieure. Simultanément, le rayon r de la plus grande sphère centrée en E et entièrement
contenue dans le secteur sf est déterminé et stocké : le résultat obtenu lors de la requête de visibilité au
point E reste valide tant que le point de vue ne quitte pas cette sphère. Lorsqu’une requête de localisa-
tion est effectuée pour un nouveau point de vue E0 , la première étape consiste à tester si jjE E0 jj r.
Lorsque c’est le cas, le résultat sauvegardé lors de la requête de visibilité depuis le point E est uti-
lisé, sans que l’étape de localisation ne doive être effectuée. Nous introduisons le facteur α, nombre
réel compris entre 0 et 1, qui indique la proportion de requêtes de visibilité qui ont effectivement été
effectuées.
Remarque : Lors de chaque déplacement de la caméra, la norme jjE E0 jj ne doit être calculée
qu’une seule fois pour tous les objets.
5 Compression de l’information 107
5 Compression de l’information
Le schéma de subdivision hiérarchique que nous utilisons pour représenter les écrans virtuels per-
met de compresser l’information de visibilité, en fusionnant les secteurs qui portent une information
redondante. Pour un objet donné, si tous les sous-secteurs issus de la subdivision d’un secteur si ont
une même distance frontière, cela signifie que la subdivision de ce secteur n’était pas nécessaire.
Nous utilisons les arbres quaternaires pour réaliser cette compression. Une fois que l’ensemble des
distances de tous les secteurs ont été calculées, nous élaguons de manière itérative les arbres qua-
ternaires représentant les secteurs, en partant des secteurs <feuilles>. Lorsque les quatre secteurs
<feuilles> issus d’un même parent possèdent une distance frontière d identique, ils sont éliminés, et
leur parent commun devient lui-même un secteur <feuille>, dont la barrière est placée à la distance d.
Le processus est répété jusqu’à ce qu’aucune simplification ne puisse avoir lieu. Ce processus permet
d’obtenir une compression sans perte de l’information de visibilité. Mais il est également possible de
compresser davantage, en utilisant une compression avec perte . Si les enfants ont des profondeurs
di similaires, nous les élaguons et assignons à leur parent une distance frontière égale à maxi=1 4 di .
:::
Le prix à payer est la perte de certaines zones d’ombre, comme montré à la Figure5.9. Pour choisir
les nœuds à supprimer, nous trions l’ensemble des fusions possibles, en fonction du volume qui serait
perdu, et fusionnons en premier lieu celle qui conduit à la perte minimum. Le processus est répété
jusqu’à ce qu’une perte totale maximum soit atteinte (approche orientée qualité) ou jusqu’à ce que la
taille en mémoire désirée soit atteinte (approche orientée budget).
Bo
un
Mer
dary
Compression
ged Bpundary
A
Bound
ary
B
Lost shadow
F IG . 5.9: Perte d’ombre due à une compression avec perte du CHR
Remarque : Ces compressions (avec et sans perte) ont été implémentées avec une petite variation.
Plutôt que de commencer par subdiviser la capsule de manière uniforme, nous utilisons une heuris-
tique simple pour détecter les secteurs qu’il n’est pas nécessaire de subdiviser. Cette heurisitique est
la suivante. Soit Ri (dN ) la région correspondant à la partie d’un secteur si située derrière la barrière
Bi , lorsque cette barrière est placée à la distance dN la plus éloignée. Si Ri (dN ) est entièrement vi-
sible depuis un des points de l’objet, cela signifie qu’il n’est pas nécessaire de subdiviser le secteur
si , car aucun de ses sous-secteurs ne pourra avoir une barrière située à distance finie. Dans notre
implémentation basée sur un échantillonnage et la technique de l’<item buffer>, le test permettant de
savoir si la région est entièrement visible est facile à réaliser, puisqu’il suffit de compter le nombre
de pixels de la région Ri (dN ) qui sont visibles depuis chaque point d’échantillonnage, et de ne pas
subdiviser le secteur si ce nombre est nul.
6 Résultats et discussion
Nous avons implémenté les algorithmes décrits dans les sections précédentes, et les avons testés
sur différentes scènes décrites dans la section 6.1. Les évaluations ont été réalisées à l’aide d’un
ordinateur portable de type Pentium 4 (1.9Ghz) comportant 1.28 Gb de mémoire centrale et une carte
graphique de type <GeForce4 Go>.
6.1 Description des scènes

L’ensemble des scènes provient du jeu <Outcast 2>, développé par l’entreprise Appeal. Nous les
avons choisies car elles sont déjà subdivisées en objets, spécifiés lors de la modélisation par les gra-
phistes, qui ont par exemple découpé le terrain en petits maillages. La Figure 5.13, située à la fin
du chapitre, montre une image des différentes scènes et illustre également leur découpage en objets.
Nous avons déjà rencontré les deux premières scènes de test, appelées <Niveau 1> et <Niveau 12>,
dans le chapitre 4. La scène de <Niveau 1>, notée (a), est une scène mixte comportant une partie
d’extérieur et une partie d’intérieur. Elle représente un paysage dans lequel un vaisseau spatial s’est
écrasé, et à l’intérieur duquel il est possible d’accéder. Le paysage est composé de végétation, de ro-
chers et de pièces dispersées du vaisseau spatial. L’intérieur du vaisseau spatial contient de nombreux
petits objets. Ce dernier et le paysage sont mutuellement visibles à travers des portes. L’espace navi-
gable de cette scène est très étendu. La scène compte 188k triangles pour 2160 objets. La scène (b),
appelée <Niveau 12>, est une scène représentant des entrepôts connectés par un réseau de couloirs.
Les entrepôts contiennent de nombreux petits objets (caisses, barils, etc.). Cette scène compte 115k
triangles répartis en 1177 objets. La complexité verticale de cette scène est réduite 6 , c’est pourquoi
elle constitue une bonne candidate pour l’encodage des écrans virtuels à l’aide de capsules. La scène
(c) est une scène architecturale simple représentant une maison, et est composée de 47k triangles pour
690 objets. Ces deux scènes architecturales possèdent des espaces navigables mieux délimités, corres-
pondant à l’étendue des bâtiments. Finalement, la scène (d), appelée <Niveau 6>, est un paysage de
pierres, contenant des pièces souterraines. Il s’agit d’un mélange de scènes d’intérieur et d’extérieur.
La scène comporte 2185 objets et 281k triangles. Tout comme la scène du <Niveau 1>, l’espace navi-
gable de cette scène est très étendu. Pour chacune de ces scènes, nous avons calculé et stocké l’ombre
Radial Capsule
Scène # Tri. # Objets Taille (Mo) Secteurs/objet Taille(Mo) Secteurs/objet
(a) Niveau 1 188k 2160 13.1Mo 3.6k 18.5Mo 5.1k
(b) Niveau 12 115k 1177 3.8Mo 2k 5.1Mo 2.7k
(c) Maison 47k 690 3.2Mo 3k 3.7Mo 3.4k
(d) Niveau 6 281k 2185 5.8Mo 1.7k 11.0Mo 3.2k
TAB . 5.1: Description des scènes de tests et caractéristiques de l’encodage des ombres.
de chacun des objets à l’aide d’un encodage radial, puis à l’aide d’un encodage par capsules. Dans
les deux cas, nous subdivisons le polyèdre initial jusqu’à un niveau de récursivité 5. Avec l’encodage
radial, il existe 1024 8 = 8192 secteurs au maximum par objet, et 1024 12 = 12288 secteurs avec
l’encodage par capsules. Dans les deux cas, nous avons appliqué l’algorithme de compression sans
perte, pour éliminer les secteurs redondants. Nous avons essayé d’utiliser des polyèdres plus subdi-
visés, mais la compression sans perte les ramenait au niveau 5, et nous avons donc conclu que ce
6 Elle n’est cependant pas assimilable à une scène 2D 12 , car sa géométrie est effectivement 3D.
6 Résultats et discussion 109
niveau de subdivision était suffisant. En ce qui concerne la profondeur, nous avons encodé les dis-
tances frontières à l’aide de 7 bits, autrement dit 128 distances frontières possibles par secteur. Les
caractéristiques des différentes scènes et des différents encodages sont données dans la Table5.1. On
constate que le nombre moyen de secteurs par objet est élevé, ce qui indique qu’il est nécessaire d’uti-
liser une subdivision fine pour approcher la visibilité dans ces scènes, comportant peu d’occultations.
6.2 Evaluation de l’algorithme

Pour chaque scène, nous avons enregistré un chemin qui la traverse, puis avons parcouru les quatre
chemins ainsi déterminés en utilisant différentes méthodes d’affichage. La méthode Full consiste à
afficher tous les objets présents dans le champ de la caméra, sans utilisation de méthode d’<occlusion
culling>. La méthode Exact correspond à l’affichage des primitives visibles. Cet ensemble est obtenu
à l’aide de la technique de l’<item buffer>. Les méthodes R et RCh correspondent à la méthode
d’<occlusion culling> basée sur l’encodage de visibilité radial par objet, respectivement sans et
avec l’exploitation de la cohérence temporelle. Finalement, C et CCh correspondent à l’encodage
par capsules, avec et sans cohérence temporelle. L’ensemble des méthodes que nous avons utilisées
est résumé dans la Table 5.2.
Méthodes d’affichage
Full Affichage de tous les objets dans le champ de la caméra (pas d’<occlusion culling>)
Exact Elimination parfaite des objets masqués
R <Occlusion culling> avec stockage radial
C <Occlusion culling> avec stockage par capsules
RCh <Occlusion culling> avec stockage radial et cohérence temporelle
CCh <Occlusion culling> avec stockage par capsules et cohérence temporelle
PV Sn <Occlusion culling> avec PVS de cellules de taille (n n n)
TAB . 5.2: Résumé des techniques de visibilité utilisées.
Pour chaque point de vue Ei le long des chemins, et pour chaque méthode d’affichage m, nous
avons mesuré le temps tm (Ei ) de génération d’une image, le nombre vm (Ei ) d’objets déclarés visibles
par la méthode m et le nombre hm (Ei ) d’objets déclarés masqués. Etant donné que les chemins ont
été choisis sans tenir compte de la visibilité, les valeurs tm (Ei ), vm (Ei ) et hm (Ei ) varient beaucoup
en fonction de Ei . Dès lors, les distributions statistiques de ces valeurs ne permettent pas d’extraire
des mesures représentatives. C’est pourquoi nous avons effectué des mesures globales d’efficacité,
mesurées pour le parcours complet du chemin. La sur-conservativité Sm de la méthode m est définie
par :
∑ vm (Ei ) ∑i vExact (Ei )
Sm = i (5.1)
∑i vExact (Ei )
Le facteur d’accélération Am de la méthode m est quant à lui défini par :
∑i tFull (Ei )
Am = (5.2)
∑i tm (Ei )
Les définitions des mesures effectuées sont résumées dans la Table5.3.
Les résultats obtenus pour chacune des scènes sont résumés dans la Table 5.4. SFull représente
la sur-conservativité lorsqu’aucune technique de visibilité n’est utilisée. En comparaison, on constate
Mesures effectuées
Ei Point de vue le long d’un chemin
vm (Ei ) Nombre d’objets visibles depuis Ei avec la méthode m
hm (Ei ) Nombre d’objets masqués depuis Ei avec la méthode m
tm (Ei ) Temps de génération d’une image depuis Ei avec la méthode m
Sm Sur-conservativité de la méthode m pour un chemin complet
Am Facteur d’accélération de la méthode m pour un chemin complet
TAB . 5.3: Résumé des mesures effectuées.
que l’encodage de visibilité au niveau des objets permet de réduire la sur-conservativité d’un ordre
de grandeur (colonne SR pour l’encodage radial et SC pour l’encodage par capsules). L’encodage de
visibilité au niveau des objets est donc efficace du point de vue de l’élimination des objets masqués. A
l’exception de la scène (a) (le <Niveau 1>), nous constatons aussi que l’encodage à l’aide de capsules
permet de détecter plus d’occultations que l’encodage radial : cela se marque particulièrement dans
la scène (b) (le <Niveau 12>), qui est un bon exemple de scène à faible complexité verticale. Mal-
heureusement, comme on peut le voir dans les colonnes <Facteur d’accélération>, les accélérations
obtenues en utilisant l’encodage des ombres par objet sont très faibles. On constate même un allonge-
ment du temps de génération des images pour la scène (d) (le <Niveau 6>), dans le cas du stockage
par capsules, qui se traduit par un facteur d’accélération de 0:9. Bien que l’utilisation de la cohérence
temporelle permette d’améliorer l’ensemble des résultats d’une dizaine de pour-cent ((colonne ARCh
pour l’encodage radial et ACCh pour l’encodage par capsules), les facteurs d’accélération restent in-
suffisants.
Le facteur d’accélération obtenu est négligeable par rapport à celui que l’on pouvait espérer en dimi-
nuant la sur-conservativité de manière aussi importante. Nous allons donc étudier dans le paragraphe
suivant les causes de ces résultats mitigés.
Sur-conservativité Facteur d’accélération

Scène SFull SR SC AR AC ARCh ACCh
a 504.3 37.8 47.6 1.1 1.1 1.3 1.2
b 1.3k 150.1 34.1 1.3 1.2 1.3 1.3
c 786.7 55.0 32.3 1.3 1.2 1.4 1.4
d 914.7 154.2 143.1 1.0 0.9 1.1 1.0
TAB . 5.4: Visibilité encodée par objet. Mesures de la sur-conservativité et du facteur d’accélération.
6.2.1 Analyse du facteur d’accélération

6.2.1.1 Estimation théorique de A L’approche que nous avons proposée impose un coût direc-
tement proportionnel au nombre d’objets de la scène, puisque chaque objet doit être interrogé pour
déterminer s’il est visible ou non. Une accélération sera obtenue si le coût supplémentaire, nécessaire
pour effectuer l’ensemble des requêtes de visibilité, est amorti par le temps qui est gagné en n’affichant
pas les objets masqués.
Soit NVisible = ∑i vCCh (Ei ) le nombre total d’objets déclarés visibles le long d’un chemin en utili-
sant la méthode de stockage par capsules avec cohérence temporelle, NMasque = ∑i hCCh (Ei ) le nombre
total d’objets déclarés masqués par la même méthode, tr le temps moyen nécessaire pour effectuer une
requête de visibilité et ta le temps moyen nécessaire pour afficher un objet à l’aide du matériel gra-
phique. Cette condition s’exprime par :
NVisible (ta + tr ) + NMasque tr < (NVisible + NMasque) ta (5.3)
ou encore :
NMasque > NVisible
tr
(5.4)
(ta tr )
Pour obtenir une accélération, la première condition à respecter est que tr < ta . En d’autres termes,
il est inutile d’appliquer des requêtes de visibilité aux objets avant de les afficher si leur temps d’affi-
chage est inférieur au temps de requête. La seconde condition à remplir concerne le nombre d’objets
masqués, qui doit être suffisamment important pour amortir le coût des requêtes. Lorsque la cohérence
temporelle est utilisée, seule une fraction α des requêtes est effectuée : le temps moyen des requêtes
est donc diminué d’autant, et la condition de gain est relâchée :
αtr
NMasque > NVisible (5.5)
(ta αtr )
Lorsque cette condition est vérifiée, le facteur d’accélération théorique AT h que l’on devrait observer
est égal à :
(NVisible + NMasque ) ta
NVisible (ta + αtr ) + NMasque αtr
AT h = (5.6)
Nous allons comparer les facteurs d’accélération mesurés le long des différents chemins avec les
valeurs calculées par l’équation 5.6. Pour ce faire, nous allons commencer par estimer ses différents
paramètres.
6.2.1.2 Mesure de tr Le coût d’une requête de visibilité dépend du nombre de secteurs utilisés
pour encoder l’ombre, c’est-à-dire de la profondeur de l’arbre utilisé pour les encoder de manière
hiérarchique (cf. paragraphe 4.2). Nous supposons dans cette analyse que le coût d’une requête de
visibilité est constant pour tous les objets d’une scène, autrement dit que tous les objets possèdent une
ombre stockée à l’aide d’un nombre de secteurs identiques. Pour mesurer tr , nous avons mesuré le
temps nécessaire pour effectuer l’ensemble des requêtes de visibilité le long des différents chemins,
et nous avons divisé ce temps par l’ensemble des requêtes de visibilité effectuées. Le temps rt est de
l’ordre de 9 10 6 seconde, soit 110k requêtes par seconde.
6.2.1.3 Mesure de α Nous avons mesuré le paramètre α, représentant la proportion de requêtes

effectivement effectuées, pour différentes vitesses de parcours des chemins. Les résultats obtenus dans
chacune des scènes étant très proches, nous les avons regroupés ; ils sont présentés dans la Table5.5.
Vitesse (m/s) 0 0.1 0.2 0.5 1

α 0 0.29 0.41 0.58 0.71
TAB . 5.5: Cohérence temporelle des requêtes de localisation.
Lorsqu’un observateur est statique, aucun objet ne doit être interrogé puisque le résultat des
requêtes précédentes reste valable : la cohérence temporelle est alors de 100%, correspondant à un pa-
ramètre α nul. Ce paramètre augmente ensuite avec la vitesse, étant donné que la cohérence temporelle
devient de plus en plus réduite. On constate que le paramètre α augmente rapidement ; cette augmen-
tation est liée directement à la subdivision importante des secteurs : chacun d’entre eux représente un
volume de l’espace très réduit, et la caméra change rapidement de secteur lors de ces déplacements.
Nous avons indiqué dans la Table 5.6 la valeur du paramètre α lorsque l’on parcourt les différents
chemins dans chaque scène à leur vitesse d’enregistrement.
6.2.1.4 Mesure de ta Nous supposons en première approximation que le temps nécessaire pour af-
ficher un objet par le système graphique est identique pour tous les objets d’une scène. Pour l’évaluer,
nous avons mesuré le temps nécessaire pour afficher l’ensemble des objets le long du chemin, et
l’avons divisé par le nombre total d’objets affichés. Le temps d’affichage ta ainsi obtenu est de l’ordre
de 20 10 6 seconde.
6.2.1.5 Comparaison entre les AT h et ACCh La Table 5.6 présente le facteur d’accélération théori-
que AT h , calculé à l’aide de l’équation (5.6), et le facteur d’accélération ACCh mesuré en pratique avec
un encodage de la visibilité par capsules et cohérence temporelle.
Mesure Prédiction
Scène tr α ta ta (NCCh ) ACCh AT h (err:) ACor (err:)
(10 6 sec.) (10 6 sec.) (10 6 sec.) (calculée par (5.6)) (calculée par (5.7))
a 9.1 0.78 19.9 45.7 1.2 1.7 (39.7%) 1.1 (8.6%)
b 8.4 0.78 25.9 117.5 1.3 2.9 (112.9%) 1.4 (6.6%)
c 8.9 0.72 25.6 82.9 1.4 2.5 (79.4%) 1.4 (2.5%)
d 8.9 0.68 15.6 42.9 1.0 1.6 (54.3%) 0.96 (7.3%)
TAB . 5.6: Comparaison du facteur d’acc élération mesuré avec celui calculé par (5.6) et (5.7).
Comme on peut le constater, il existe un écart important entre les valeurs théorique et observée
(l’erreur relative entre ces deux valeurs est indiquée entre parenthèses). Nous avons identifié les causes
de cet écart : il provient du comportement fortement non linéaire du système d’affichage graphique.
Contrairement à nos suppositions initiales, le temps d’affichage ta d’un objet n’est pas constant, et
dépend fortement du nombre d’objets affichés pour générer l’image (cf. annexe page 119). Nous
avons modifié l’équation 5.6 afin de tenir compte de cette non linéarité, et utilisons deux temps d’af-
fichage distincts : ta (NFull ) représente le temps moyen d’affichage lorsque l’ensemble de la scène est
affiché (en utilisant la méthode Full)7 , et ta (NCCh ) le temps moyen d’affichage lorsque seuls les objets
déclarés visibles par l’encodage par capsules sont affichés. Nous obtenons le facteur d’accélération
corrigé :
(NVisible + NMasque ) ta (NFull )
NVisible (ta (NCCh ) + αtr ) + NMasque αtr
ACor = (5.7)
Les résultats obtenus à l’aide de cette formule sont donnés dans la colonne ACor : on constate qu’ils
correspondent mieux au gain mesuré en pratique ACCh (l’erreur relative entre la valeur théorique et la
valeur mesurée est indiquée entre parenthèses). Nous attribuons l’erreur subsistante aux fluctuations
de la valeur ta qui existent en pratique. Nous considérons donc que l’équation (5.7) reflète le compor-
tement de l’algorithme, et nous allons l’exploiter dans le paragraphe suivant pour augmenter le facteur
d’accélération.
7 Le temps ta (NFull ) correspond donc au temps ta utilisé ci-dessus.
6.2.2 Augmentation du facteur d’accélération

Le temps moyen d’affichage ta est proche du temps tr . Ceci explique pourquoi les facteurs d’accé-
lération obtenus sont si faibles : il est presque aussi efficace d’afficher un objet que de déterminer
s’il est visible. D’après la condition (5.5), il est nécessaire d’éliminer un très grand nombre d’ob-
jets masqués pour qu’une accélération soit obtenue. En fait, le temps ta est réduit car les conditions
d’affichage sont très favorables : nous stockons les maillages sous la forme optimisée de <triangle
strips>, les données résident en mémoire vidéo, et aucun calcul d’éclairage n’est effectué (les objets
sont affichés avec une couleur précalculée par sommet). Les performances d’affichage se situent au-
tour de 5 millions de triangles par seconde, valeur proche des performances maximum de la carte
graphique utilisée. Il est dès lors très difficile d’obtenir un gain de temps significatif à l’aide de notre
algorithme. Afin de l’évaluer dans de meilleures conditions, nous avons réalisé l’expérience suivante.
Avant la phase d’exploration interactive, nous avons subdivisé chaque triangle de la scène en quatre
triangles, et avons augmenté de la sorte artificiellement le nombre de triangles de la scène par quatre.
Les résultats sont donnés dans la Table 5.7. Le temps ta étant plus élevé, les facteurs d’accélération
mesurés sont plus importants : une accélération de 3:8 est même obtenue pour la scène du <Niveau
12>. Pour information, nous avons indiqué dans la colonne ACor le gain théorique calculé à l’aide de la
formule 5.7 (l’erreur relative étant toujours indiquée entre parenthèses), qui est en adéquation avec les
mesures effectuées. Conformément à l’intuition, on en conclut que la méthode est adaptée aux scènes
dont les objets sont coûteux à afficher. Outre l’affichage d’objets dont le maillage est très détaillé, ce
sera également le cas lorsque des effets complexes d’éclairage sont utilisés, ou encore si des calculs
sont effectués au niveau du pixel lors de l’affichage 8 .
Mesure Prédiction
Scène tr α ta (NFull ) ta (NCCh ) ACCh ACor ( Er:)
(10 6 sec.) (10 6 sec.) (10 6 sec.)
a 9.1 0.78 86.2 118.4 2.4 2.4 (2.0%)
b 8.4 0.78 96.5 174.1 3.8 4.1 (6.3%)
c 8.9 0.72 68.6 118.5 2.8 2.9 (2.8%)
d 8.9 0.68 130.4 188.1 2.7 2.5 (5.1%)
TAB . 5.7: Comparaison du facteur d’acc élération mesuré avec celui calculé par (5.6) et (5.7) lorsque les
primitives de la scène sont subdivisées.
6.3 Comparaison avec des PVS

Les scènes que nous avons choisies sont très diversifiées et leur géométrie quelconque. Dès lors, la
seule technique alternative pour précalculer l’<occlusion culling> est d’utiliser la technique du PVS.
C’est pourquoi nous avons comparé nos résultats avec ceux obtenus par cette méthode. Pour ce faire,
nous avons placé des cellules de manière régulière le long des chemins utilisés dans les paragraphe
précédents, chaque cellule étant un cube aligné par rapport aux axes. Nous sommes parti de cellules
de taille (1m 1m 1m), formant ensemble les cellules du PV S1 , puis avons fait varier leur volume
en doublant de manière successive la taille de leurs côtés. Nous avons obtenu de la sorte les cellules
des PV S2 (2m 2m 2m), PV S4 (4m 4m 4m) et PV S8 (8m 8m 8m) Les PVS en eux-mêmes
ont été évalués à l’aide d’une technique agressive d’échantillonnage, consistant à calculer l’union des
PVS obtenus à l’aide d’un <item buffer> depuis de nombreux points d’échantillonnage (cf. page53).
8 A l’aide de la technologie des <pixel shaders> par exemple.
Nous présentons d’abord une comparaison qualitative de la sur-conservativité obtenue pour les quatre
PVS et l’encodage par capsules avec cohérence temporelle, puis une comparaison de leur efficacité.
Nous terminons cette comparaison par l’étude du coût mémoire qu’elles impliquent.
6.3.1 Comparaison qualitative de la sur-conservativité

La Figure 5.10 représente l’évolution de la sur-conservativité 9 lorsque l’on parcourt le chemin,
dans deux scènes très différentes : la scène (a) du <Niveau 1> qui est un mélange de scènes d’intérieur
et d’extérieur et la scène (b) du <Niveau 12> qui est une scène d’intérieur. Dans le <Niveau 1>,
la première partie du chemin (allant jusqu’à l’image 800) est située en extérieur. Dans cette situa-
tion, l’encodage par capsules présente une sur-conservativité située entre celle de cellules de taille
(8 8 8) et de cellules de taille (4 4 4), qui sont relativement larges. Dans la seconde partie du
chemin, nous sommes à l’intérieur de la navette spatiale, et l’encodage par capsules est quasiment
aussi efficace que des cellules de taille 2 2 2. Dans le <Niveau 12>, qui est entièrement une scène
d’intérieur, les résultats de l’encodage par capsules sont quasiment équivalents à ceux des cellules de
taille (1 1 1). De plus, on peut remarquer dans les deux scènes que la sur-conservativité obtenue
à l’aide des capsules est plus ou moins <constante>, et ce, aussi bien en intérieur qu’en extérieur –
c’est-à-dire que l’ensemble vC (Ei ) des objets considérés comme visibles a plus ou moins le même pro-
fil que l’ensemble vExact (Ei ) exact d’objets visibles – ce qui n’est pas le cas pour le PVS obtenu avec
des cellules. En effet, il n’est pas judicieux d’utiliser des cellules disposées de manière régulière dans
les scènes d’intérieur, car elles se trouvent souvent à cheval entre plusieurs pièces : il en résulte un
PVS très conservatif. De plus, la courbe de conservativité le long d’un chemin présente des variations
brutales lorsque l’on change de cellules. Au contraire, les capsules capturent les événements de visi-
bilité de manière fine. Par exemple, lorsque l’on se déplace derrière un arbre, les capsules permettent
d’éliminer les petits objets masqués par le tronc.
6.3.2 Efficacité pour l’<occlusion culling>

La sur-conservativité et les facteurs d’accélération obtenus avec les différents PVS sont présentés
dans la Table 5.8.
Sur-conservativité Accélération
Scène SPV S1 SPV S2 SPV S4 SPV S8 APV S1 APV S2 APVS4 APV S8
a 17.7 30.3 54.6 86.5 2.1 2.0 1.8 1.6
b 27.0 86.9 236.6 704.0 1.8 1.6 1.4 1.1
c 24.6 62.5 201.6 370.8 1.7 1.7 1.3 1.2
d 28.2 55.7 119.2 289.5 2.0 1.9 1.7 1.4
TAB . 5.8: Sur-conservativité et facteur d’accélération obtenus à l’aide de PVS de diff érentes résolution.
Du point de vue de la sur-conservativité, les mesures confirment les observations quantitatives du

paragraphe précédent : l’encodage à l’aide des capsules permet d’atteindre des performances com-
prises comprises entre celles du PV S1 et du PV S2 . Les performances dans les scènes d’extérieur
sont un petit peu moins bonnes, les résultats obtenus étant compris entre ceux du PV S4 et du PV S8
(scènes (a) du <Niveau 1> et (d) du <Niveau 6>). Cela confirme l’efficacité de la méthode en terme
9 Dans ce paragraphe, et contrairement aux paragraphes précédents, nous évaluons la sur-conservativité en chacun des
points de vue Ei .
(a)
(b)
F IG . 5.10: Les ensembles visibles et potentiellement visibles (avec PVS et encodage par capsules) le long de
chemins enregistrés dans le <Niveau 1> (a) et dans le <Niveau 12> (b). L’axe x indique la position le long du
chemin et l’axe y indique le nombre d’objets dans les diff érents ensembles.
d’élimination des objets masqués, puisqu’il est nécessaire d’utiliser des <PVS> composés de très pe-
tites cellules pour obtenir une efficacité similaire.
Du point de vue du temps de génération d’une image, les <PVS> sont beaucoup plus efficaces
que l’encodage par capsules. Cette conclusion est logique au vu de la discussion présentée au pa-
ragraphe 6.2.1. En effet, dans le cas de l’utilisation de PVS, une requête de visibilité consiste simple-
ment à tester une variable booléenne, le coût tr est négligeable. Si ta (NPV S ) est le temps d’affichage
moyen d’un objet lorsque la méthode de PVS est utilisée, l’équation 5.7 se simplifie et l’accélération
théorique obtenue avec une méthode basée sur les PVS est égale à :
NVisible + NMasque ta (NFull )

APV S = (5.8)
NVisible ta (NPV S )
Pour une sur-conservativité identique, ta (NPV S ) est égal à ta (NCCh ), et l’on constate que APV S sera
toujours supérieur à ACor .
En conclusion, l’encodage par capsules permet d’obtenir une sur-conservativité faible, comparable
à celle obtenue avec les PV S1 et PV S2 , qui sont des PVS utilisant des petites cellules. Cependant, les
gains de temps liés à cette faible sur-conservativité ne compensent pas le temps consacré aux requêtes,
même par rapport aux PV S4 et PV S8 , dont les cellules sont de grande taille.
6.3.3 Occupation mémoire

Nous avons finalement comparé l’encodage par objet et les PVS du point de vue de leur occupation
mémoire, afin de déterminer quel encodage est le plus compact. Nous avons d’abord étudié la relation
entre la consommation de mémoire et la sur-conservativité pour les deux méthodes. La Figure5.11(a)
montre le comportement théorique que nous devons espérer.
250
CHR
PVS 1 ( 74 x 74 x 5 m)
PVS 2 ( 105 x 105 x 5 m)
PVS 3 ( 148 x 148 x 5 m)
PVS 4 ( 210 x 210 x 5 m)
200 PVS 5 ( 297 x 297 x 5 m)
PVS 6 ( 297 x 297 x 10 m)
Over−conservativity (%)
150
100
50
0
0 5 10 15 20 25 30 35 40 45 50
Memory cost (Mb)
(a) (b)
F IG . 5.11: Sur-conservativité vs. coût mémoire : comparaison de l’encodage par capsules et des PVS par
cellule. (a) comparaison th éorique (b) comparaison pour la sc ène du <Niveau 1>.
Le coût mémoire des capsules est égal au nombre d’objets, multiplié par la taille mémoire des cap-
sules. Pour un nombre fixé d’objets, nous pouvons changer ce coût en appliquant une compression aux
capsules (cf. section 5) : la sur-conservativité restera constante. Nous pouvons augmenter la compres-
sion en autorisant une perte, c’est-à-dire une augmentation de la sur-conservativité. La courbe obtenue
est indiquée en pointillé dans la Figure 5.11. Notons que la sur-conservativité ne peut pas descendre
en dessous d’une certaine valeur Smin , même en utilisant une capsule très subdivisée. Cette valeur est
liée à la taille des objets, qui restreint les ombres que l’encodage par capsules est capable de capturer.
7 Conclusion et travail futur 117
Notons cependant que Smin peut être réduite en subdivisant chaque objet en sous-parties. La courbe
obtenue est indépendante de la taille de l’espace navigable. Mais il en est tout autrement lorsque l’on
utilise un <PVS>. Dans ce cas, il est nécessaire de diminuer la taille des cellules pour diminuer la
sur-conservativité. Le coût mémoire étant directement lié au nombre de cellules, un faible coût im-
plique un petit nombre de cellules (c-à-d des cellules larges) et par conséquent une sur-conservativité
élevée. Réciproquement, un coût mémoire élevé permet d’utiliser un nombre élevé de cellules (c-à-d
des petites cellules) et une sur-conservativité qui tend vers zéro. Dès lors, pour un coût mémoire fixé,
l’augmentation de l’espace navigable ne peut être obtenue qu’en augmentant la taille des cellules,
et donc en augmentant également la sur-conservativité. Nous avons représenté dans la Figure5.11
différentes courbes, chacune représentant un PVS de coût mémoire identique, mais pour des espaces
navigables de différentes tailles. La Figure 5.11(b) montre les mesures obtenues en pratique dans la
scène du <Niveau 1>. Les courbes obtenues correspondent aux prévisions théoriques. Pour un espace
navigable donné, l’intersection entre la courbe de l’encodage par capsules et la courbe correspondant
aux PVS indique la limite à partir de laquelle il est avantageux d’utiliser un encodage par capsules à la
place d’un PVS, du point de vue de l’espace mémoire 10 . Nous avons finalement comparé le nombre
de cellules qui seraient nécessaires si l’on voulait couvrir l’entièreté de l’espace navigable avec des
cellules, avec le nombre de secteurs utilisé pour encoder l’ensemble des ombres. Cette comparaison
montre que le nombre de secteurs est du même ordre de grandeur que le nombre de cellules du PV S1
pour les scènes (a) et (d), qui possèdent de larges espaces navigables. Il est cependant beaucoup plus
important que le nombre de cellules pour les autres scènes, dont l’espace navigable est réduit. Cette
table permet d’évaluer le coût mémoire des différents types de représentations. L’encodage par écrans
virtuels nécessite un seul bit par secteur 11 . Au contraire, les <PVS> doivent stocker la liste des objets
visibles en chacune des cellules : pour un nombre de secteurs identique au nombre de cellules, le coût
mémoire des <PVS> sera donc beaucoup plus élevé.
Espace navigable (mètres) # secteurs # cellules

Scène Radial Capsule PV S1 PV S2 PV S4 PV S8
a 300 150 300 16.5M 23.3M 13.5M 1.7M 211k 26k
b 110 20 110 4.8 M 6.4M 242.0k 30.3k 3.7k 472
c 50 35 50 4M 4.6M 87.5k 10.9 k 1.4k 170
d 400 100 550 7.5 M 13.9M 22.0M 2.8M 343k 43k
TAB . 5.9: Description des scènes de test.
En conclusion, l’encodage de l’ombre des objets est avantageux par rapport à un encodage par
PVS du point de vue de l’occupation mémoire lorsque la taille de l’espace navigable augmente,
car le nombre de cellules deviendrait alors prohibitif pour permettre d’offrir une sur-conservativité
équivalente.
7 Conclusion et travail futur

Dans ce chapitre, nous avons présenté une méthode originale pour encoder la visibilité dans une
scène 3D, consistant à associer à chaque objet une information permettant de déterminer s’il est vi-
10 Cettecomparaison n’est évidemment pas complète étant donné que le coût mémoire des cellules peut être réduit en
comprimant les PVS [157, 170].
11 Comme il est nécessaire de stocker de l’information supplémentaire pour encoder l’arbre quaternaire représentant la
subdivision hiérarchique des secteurs, le nombre de bits par secteur est en réalité un petit peu plus élevé.
sible depuis tout point de l’espace. Cette méthode élimine le problème du placement des cellules, qui
se pose lorsque l’on encode la visibilité à l’aide de la technique des <PVS>. La taille de l’espace
navigable n’est plus critique, et cette technique offre la possibilité de réaliser l’élimination des objets
masqués même si l’espace navigable n’est pas connu à priori. En utilisant cette méthode, il est donc
possible de naviguer dans l’entièreté de l’espace 3D, et même d’observer la scène depuis l’extérieur.
Il serait impossible d’obtenir ce type de navigation avec des <PVS>, puisque l’espace navigable est
illimité. Nous avons montré que l’information de visibilité associée à un objet pouvait être représentée
à l’aide d’écrans virtuels. En utilisant ce formalisme, n’importe quel type d’écrans virtuels proposé
dans la littérature peut être utilisé : la seule condition est que la localisation de la caméra puisse être
effectuée de manière efficace.
Cependant, l’analyse des résultats montre que le stockage de la visibilité au niveau des objets ne per-
met pas toujours d’obtenir les gains escomptés. Nous avons mis en évidence deux causes principales
de l’obtention de ces résultats mitigés :
– le choix des écrans virtuels n’est pas optimal.
– l’encodage de l’information de visibilité au niveau des objets n’est pas suffisant, et il serait
nécessaire de la stocker de manière hiérarchique.
Ces deux points sont détaillés dans les sections suivantes, à la suite desquelles nous proposons
d’appliquer le principe de la détermination de la visibilité depuis les objets au calcul de <PVS>.
7.1 Ecrans virtuels

Le choix des écrans virtuels est crucial, car ce sont eux qui définissent l’ombre qu’il est possible
d’encoder, et de ce fait la sur-conservativité de la méthode. Etant donné qu’ils sont interrogés avant
d’afficher un objet, ils influencent également le temps d’affichage : la requête de visibilité doit pouvoir
être effectuée plus rapidement que l’affichage de l’objet en lui-même pour qu’un gain de temps puisse
être obtenu. Comme écrans virtuels, nous avons choisi d’utiliser des barrières virtuelles, similaires
aux <GOM> proposés par Hua et al. [86]. Nous avons d’abord utilisé un encodage radial, offrant
l’avantage d’être isotrope. Mais étant donné que seule une partie des ombres pouvait être capturée
à l’aide de cette représentation dans les scènes à faible complexité verticale, nous avons proposé un
encodage des écrans à l’aide de capsules, permettant effectivement de diminuer la sur-conservativité
de manière significative dans certaines scènes telles que le <Niveau 12>.
Malheureusement, les écrans virtuels que nous avons utilisés ne sont pas les mieux adaptés. Tout
d’abord, et contrairement à nos espérances, il est nécessaire de subdiviser les secteurs de manière
fine pour obtenir une représentation des ombres de qualité. De plus, ces écrans virtuels perdent de
leur efficacité lorsque la taille des objets augmente car les ombres deviennent de moins en moins
radiales et les écrans sont pris en défaut. Finalement, le coût d’interrogation des écrans virtuels n’est
pas négligeable, à cause du haut degré de subdivision des capsules. Même si la cohérence temporelle
permet de réduire ce temps d’interrogation, cette réduction reste limitée car la cohérence temporelle
n’est pas très élevée, également à cause de la subdivision importante des capsules12 .
Comme travail futur, il nous apparaı̂t primordial de mettre au point de nouveaux écrans virtuels plus
compacts, plus rapides à interroger, et permettant d’encoder l’ombre des objets de grande taille, car
c’est à ce prix que la méthode que nous avons proposée sera réellement attrayante par rapport à
une méthode de <PVS>. Une piste intéressante serait d’utiliser comme écrans virtuels des contours
polygonaux à la place de la représentation discrète, tels que les <Hoops> [26] par exemple.
12 Notons que l’implémentation a été réalisée en vue de limiter le coût mémoire, et nous n’avons pas essayé d’optimiser
la vitesse des requêtes de visibilité (et en particulier les parcours d’arbre). Une implémentation optimisée de ce point de vue
permettrait sans doute d’augmenter sensiblement la vitesse des requêtes.
7.2 Encodage hiérarchique

Dans l’état actuel de nos travaux, le coût d’utilisation de la méthode est linéaire en fonction du
nombre d’objets. Il ne s’agit donc pas d’un algorithme d’<occlusion culling> à proprement parler,
puisque la complexité de la méthode est proportionnelle à la taille des données en entrée, et non pas au
nombre de primitives visibles (la taille des données en sortie). Une approche hiérarchique résoudrait
ce problème. En effet, en groupant les objets dans une structure de données arborescente, il serait
possible de stocker une ombre pour chaque nœud de la hiérarchie : pendant la phase de navigation
interactive, un ensemble d’objets pourrait être éliminé à l’aide d’une seule requête appliquée au nœud
parent, lorsque ce dernier est masqué.
Soit un ensemble de k objets Oi regroupés dans le nœud n d’une hiérarchie, et soitUi l’ombre associée
T
à l’objet Oi . L’ombre à stocker au niveau du nœud n est égale à l’intersection géométrique des ombres
de l’ensemble des k objets que n regroupe, soit i=1 k Ui . L’utilisation des capsules n’étant pas du tout
::
adaptée à ces calculs d’intersection, nous n’avons pas pu évaluer les bénéfices d’une implémentation
hiérarchique. Cependant, Stewart a utilisé avec succès cette approche dans le cas spécifique de la
visualisation de terrain [147] : l’intersection des ombres est calculée en utilisant des lignes d’horizon
comme écrans virtuels, qui ont la propriété de se combiner facilement pour créer une représentation
hiérarchique. Malheureusement, cette approche est limitée aux champs de hauteurs, et un travail futur
très prometteur serait de l’étendre aux scènes 3D. Pour ce faire, il faudrait tenir compte de la contrainte
du calcul des intersections d’ombres dès l’élaboration des écrans virtuels, afin d’obtenir un encodage
permettant de calculer aisément l’ombre à associer aux nœuds intermédiaires de la hiérarchie. Dans
ce cas aussi les <Hoops> sont de bons candidats puisqu’il existe déjà un algorithme permettant de
combiner plusieurs d’entre eux [26].
7.3 Application au calcul de <PVS>

L’idée d’un calcul de visibilité depuis les objets pourrait être appliquée au calcul de <PVS>. Plutôt
que de calculer l’ensemble des objets visibles depuis chaque cellule, l’idée consisterait à calculer
l’ensemble des cellules visibles depuis chaque objet. Dès lors, la complexité du précalcul serait liée
au nombre d’objets plutôt qu’au nombre de cellules, ce qui permettrait d’augmenter le nombre de
cellules et de les placer de manière plus appropriées. L’utilisation d’un <PVS> permettrait quant à elle
d’éliminer le coût d’utilisation qui handicape les méthodes stockant les ombres des objets présentées
dans ce chapitre. Il serait ensuite intéressant de comparer l’efficacité du précalcul obtenu avec celui
sensible à la taille des données en sortie présenté récemment par Samuli Laine [96].
Annexe : temps d’affichage en fonction du nombre d’objets affichés

Nous avons mesuré le temps moyen ta d’affichage d’un objet en fonction du nombre d’objets af-
fichés à l’aide de la technique Full. La Figure 5.12 donne la courbe obtenue en cumulant les résultats
mesurés le long de l’ensemble des chemins utilisés dans la section <Résultat>, toutes scènes confon-
dues. Comme on peut le constater, le temps d’affichage par objet n’est pas constant, mais est au
contraire fortement non linéaire. Nous avons calculé l’équation qui approchait le mieux cette courbe
au sens des moindres carrés : ta = 1:110 3 vFull (Ei ) 0 625 (courbe en rouge sur le graphique).
:
Ce comportement non linéaire explique les faibles gains obtenus lorsque l’on utilise un algorithme
d’<occlusion culling> dans une scène de faible complexité, pour laquelle le système d’affichage n’est
−5
x 10
8
Ta (sec.)
4
1
0 200 400 600 800 1000
Nombre d’objets
F IG . 5.12: ta en fonction du nombre v Full (Ei ) d’objets affichés.
pas <saturé> : ta diminue lorsque le nombre d’objets affichés augmente. Il est donc d’autant plus dif-
ficile d’obtenir un gain, puisque l’élimination d’objets masqués augmente le temps moyen d’affichage
par objet, ce qui peut paraı̂tre paradoxal. C’est également pour cette raison que nous avons dû utiliser
des formules corrigées pour estimer les accélérations obtenues.
Scène (a) - Niveau 1 (2160 objets, 188k tri.)
Scène (b) - Niveau 12 (1177 objets, 115k tri.)
Scène (c) - Maison (690 objets, 47k tri.)
Scène (d) - Niveau 6 (2185 objets, 281k tri.)
F IG . 5.13: Scènes de test. La colonne de gauche pr ésente une vue générale de la scène ; dans celle de droite,
chaque objet a été mis en évidence à l’aide d’une couleur particuli ère. Note : pour la scène (a), le deux images
ont été réalisées depuis des points de vue différents.
C r é a t i o n v o l u m i q u e d e g r a p h e s
chapitre 6
cellules-portails
Sommaire
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
1.1 Plan du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
1.2 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2 Etat de l’art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
2.1 Génération de graphes cellules-portails . . . . . . . . . . . . . . . . . . . 125
2.2 <Watershed> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
2.3 Champ de distances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
3 Génération automatique de graphes cellules-portails . . . . . . . . . . . . . . . 127
3.1 Présentation de l’algorithme de <watershed> . . . . . . . . . . . . . . . . 127
3.2 Utilisation du <watershed> pour la génération de graphes cellules-portails . 128
4 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.1 Etape 1 : Calcul du champ de distances . . . . . . . . . . . . . . . . . . . 131
4.2 Etape 2 : Détection des portails . . . . . . . . . . . . . . . . . . . . . . . 131
4.3 Etape 3 : Création des portails . . . . . . . . . . . . . . . . . . . . . . . . 132
4.4 Etape 4 : Création des cellules . . . . . . . . . . . . . . . . . . . . . . . . 134
5 Implémentation hiérarchique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
6 Sur-segmentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.1 Elimination des détails . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.2 Voxelisation robuste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
7 Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
7.1 Etude qualitative des graphes générés . . . . . . . . . . . . . . . . . . . . 138
7.2 Statistiques concernant la génération des graphes . . . . . . . . . . . . . . 142
7.3 Utilisation du <CPG> pour l’<occlusion culling> . . . . . . . . . . . . . . 142
8 Conclusions et perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
1 Introduction
Les environnements architecturaux, très répandus dans les applications de réalité virtuelle, sont
intéressants du point de vue de l’<occlusion culling> car les occultations y sont nombreuses : à tout
124 chapitre 6. Création volumique de graphes cellules-portails
instant, seule une petite partie de la scène est visible. L’essentiel de la géométrie est masquée par les
murs, ce qui donne la possibilité d’utiliser des algorithmes adaptés, plus efficaces que les algorithmes
qui ne font aucune supposition sur le type de scène rencontré.
De ce fait, les graphes cellules-portails sont utilisés de manière presque universelle pour l’élimination
des objets masqués dans ce genre d’environnement. Pour rappel, un graphe cellules-portails (que nous
notons CPG) est un graphe qui encode les relations de visibilité au sein d’une scène 3D. Les nœuds du
graphe sont appelés les cellules, et correspondent typiquement aux pièces d’un bâtiment. Elles sont
connectées par les portails qui correspondent à ses ouvertures (c-à-d ses portes et ses fenêtres). La
visibilité est déterminée en considérant qu’une cellule ne peut voir les autres cellules qu’à travers une
séquence de portails (cf. état de l’art page 60).
Dans ce chapitre, nous étudions les méthodes de génération automatique de graphes cellules-
portails. La difficulté de ce type de techniques réside dans le fait qu’il est possible de décomposer
une scène en un nombre illimité de graphes CPG. En termes de performances d’affichage, un bon
graphe doit réaliser un compromis entre le nombre de portails et son coût d’utilisation : le nombre
de portails doit être minimisé pour réduire le temps de calcul consacré à l’élimination des objets
masqués, mais ces portails doivent être suffisamment nombreux et correctement placés pour dimi-
nuer la sur-conservativité. Un bon compromis est obtenu en utilisant une <décomposition classique>,
dans laquelle les cellules sont les pièces et les portails sont les ouvertures. Pour créer ce type de
décomposition, une possibilité très utilisée en pratique consiste à générer les graphes <CPG> à la
main, au moyen d’outils associés aux logiciels de modélisation. Mais les résultats ne sont pas toujours
satisfaisants, et cette manière de procéder limite l’utilisation des graphes CPG aux seuls spécialistes.
Au contraire, un algorithme de génération automatique permettrait à tout utilisateur de bénéficier de
graphes CPG pour accélérer l’affichage, mais offrirait aussi des gains de temps et d’argent importants
dans l’industrie du jeu vidéo en libérant les graphistes de cette tâche.
C’est pourquoi des approches de génération automatique ont été développées. Malheureusement,
les méthodes existantes sont limitées à des scènes très particulières (scènes architecturales pures,
scènes tubulaires, scènes de villes, etc.) et ces méthodes ne peuvent être utilisées lorsque le modèle
sort du cadre pour lequel elles ont été mises au point. A notre connaissance, aucune d’entre elles n’est
capable de traiter tous les types de modèles de manière unifiée.
Dans ce chapitre, nous reformulons le problème de la génération automatique de graphe cellules-
portails en termes de segmentation d’images 3D 1 . L’image utilisée est une représentation volu-
mique intermédiaire de la scène (un champ de distances), les objets à séparer étant les cellules
et les séparateurs étant les portails. Cette formulation nous permet d’adapter un outil très puissant
de segmentation d’images, l’algorithme de lignes de partage des eaux (appelé <watershed> en an-
glais) [112]. Le résultat est un algorithme permettant de générer de manière automatique un graphe
cellules-portails. Contrairement aux approches précédentes, cet algorithme est indépendant de la
manière dont la scène est représentée (surfaces paramétriques, surfaces implicites, représentations vo-
lumiques, maillages polygonaux, etc.). De plus, nous montrons qu’il est capable de traiter de manière
unifiée une grande variété de scènes.
Remarque : Ces travaux ont fait l’objet d’une publication à la conférence <Eurographics> en 2003,
sous le tire <Volumetric Cell-and-Portal Generation>, récompensée par le prix <Best Student Pa-
per Award : Honourable Mention> [81]. Ils ont été réalisés en collaboration avec Olivier Debeir et
François Sillion.
1 En traitement d’images, la segmentation désigne le processus qui consiste à séparer les différents objets d’une image.

Nous commençons par présenter un état de l’art concernant les techniques utilisées (section2).
Nous décrivons ensuite l’algorithme de <watershed>, sur lequel est basé notre méthode, puis présentons
le principe général de notre méthode de génération de graphes CPG (section3). Nous détaillons les
différentes étapes de l’algorithme dans la section 4. Pour limiter le coût mémoire de la méthode, nous
présentons une version hiérarchique de l’algorithme dans la section 5. Les problèmes potentiels et
leurs solutions sont abordés dans la section 6. Nous présentons ensuite les résultats dans la section 7.
Finalement, nous concluons et donnons des directions de recherche future dans la section8.
1.2 Contributions
Formulation du problème en termes d’analyse d’images Comme expliqué ci-dessus, notre prem-
ière contribution consiste à formuler le problème de génération automatique de graphes CPG en termes
d’analyse d’images, et à utiliser un algorithme de segmentation d’images pour générer le graphe
(section 3.1).
Algorithmes de positionnement de portails Nous proposons deux algorithmes permettant de po-

sitionner les portails, l’un basé sur le squelette du champ de distances, et le second utilisant une
technique d’analyse d’images (section 4.3.1).
Encodage implicite des cellules Nous introduisons l’idée de stocker la forme géométrique des cel-
lules de manière implicite, en associant un simple identifiant à chaque objet de la scène (section4.4).
Implémentation hiérarchique du <watershed> Pour résoudre le coût mémoire de la méthode,

nous stockons le champ de distances sous la forme d’une structure de données hiérarchique. Nous
proposons une implémentation hiérarchique de l’algorithme de <watershed>, utilisant cette structure
de données (section 5).
Réduction du bruit par voxelisation L’algorithme de <watershed> est très sensible au bruit présent
dans les images. Nous proposons l’utilisation d’une procédure de voxelisation robuste comme pré-
traitement automatique, afin de filtrer le bruit présent dans le champ de distances (section6.2).
2 Etat de l’art
2.1 Génération de graphes cellules-portails
Nous avons déjà présenté les algorithmes de génération automatique de graphes cellules-portails
dans le chapitre 3, page 61. La méthode que nous proposons étant basée sur un champ de distances à
la géométrie de la scène, notre travail peut être vu comme une extension de l’algorithme de Hong et
al. [85]. La différence est que notre technique a été imaginée pour des modèles arbitraires, à la place
de la géométrie très particulière du colon humain.
2.2 <Watershed>
L’algorithme de <watershed> est un outil puissant d’analyse d’images, conçu initialement pour
la segmentation d’images en niveaux de gris [112]. Le lecteur trouvera une bonne introduction à cet
algorithme et à ces différentes implémentations dans [133].
Même si l’algorithme peut être étendu depuis la 2D vers la 3D, il est nécessaire en 3D de faire face
aux coûts importants de stockage et de calcul [148]. Une implémentation optimisée, minimisant l’uti-
lisation mémoire afin de traiter les grands volumes de données 3D du domaine médical a été proposée
par Felkel et al. [62]. Citons pour finir les travaux de Mangan et al. [109], qui utilisent une adaptation
de l’algorithme de <watershed> définie sur la surface d’un maillage 3D en vue de le segmenter.
2.3 Champ de distances

2.3.1 Définition
Un champ de distances échantillonné est un champ scalaire discret, chacun des points échantillons
contenant la distance à la primitive géométrique la plus proche. Les champs de distances ont été
utilisés dans de nombreux domaines tels que le graphisme, la robotique, la visualisation scientifique,
la modélisation géométrique et l’analyse d’images. Citons comme applications la représentation de
surface [64], la sculpture virtuelle [126], la détection de collisions [89], le calcul de chemins [7], le
<morphing> entre objets [37] ou encore la segmentation d’images [72].
2.3.2 Calcul de champs de distances

Le calcul d’un champ de distances nécessite une fonction h(P) qui donne la distance entre le
point P(x; y; z) 2 R3 et la primitive géométrique la plus proche. Si la géométrie est représentée par des
maillages polygonaux, la fonction h(P) fournit la distance minimum entre le point P et chacun des
polygones de la scène. Si elle est représentée par une surface implicite s(x; y; z) = 0, la distance h(P)
correspond directement à s(P), c’est-à-dire la valeur de la fonction implicite évaluée au point P.
Une approche naı̈ve évalue indépendamment la distance pour tous les points du champ de dis-
tances. Malheureusement, ce type de requête est très coûteux, du moins dans le cas des maillages po-
lygonaux, et ce, même si les polygones sont organisés spatialement à l’aide d’une structure de données
hiérarchique (telle qu’un <octree> 2 , un arbre <BSP> ou une hiérarchie de boı̂tes englobantes) et le
temps de calcul du champ de distances devient problématique. Des algorithmes plus sophistiqués uti-
lisent les propriétés particulières de la fonction de distances (continuité, croissance constante) pour
accélérer le temps de calcul. Plusieurs méthodes, telles que celles présentées dans [134], ont été pro-
posées pour résoudre le problème du temps de calcul important impliqué par le calcul du champ de
distances. Cet algorithme donne une approximation du champ de distances qui est très rapide à calcu-
ler mais relativement imprécise. L’algorithme parcourt l’ensemble des voxels du champ de distances
en deux passes successives. Chaque passe propage une distance locale, calculée en ajoutant aux va-
leurs de distances déjà calculées les valeurs stockées dans la matrice locale de distances. La première
passe <vers l’avant> calcule la distance depuis la surface dans une direction <top-down> arbitraire,
en partant du coin en haut à gauche de la grille et en se déplaçant vers le bas. La passe en arrière cal-
cule les distances manquantes, depuis le coin inférieur de la grille vers le début de celle-ci. La vitesse
2 Un <octree> est un arbre dont chaque nœud est une boı̂te alignée par rapport aux axes, chaque nœud étant subdivisé
en huit enfants égaux.
3 Génération automatique de graphes cellules-portails 127
de l’algorithme provient des calculs simples utilisés. Récemment, une technique de calcul rapide, ex-
ploitant le matériel graphique, a été proposée [150]. Nous renvoyons le lecteur à cet article et à la
thèse d’Olivier Cuisenaire [121] pour un état de l’art concernant les méthodes de calcul de champs de
distances.
2.3.3 <Adaptively Sampled Distance Fields> (<ADF>)

Une représentation hiérarchique des champs de distances a été proposée par Frisken et al. pour
réduire leur coût de stockage [64] (cf. Figure 6.1).
F IG . 6.1: <Adaptively Sampled Distance Fields> en 2D (image tir ée de [64]). (a) Image binaire représentant
la lettre R. (b) Champ de distances correspondant. (c) Encodage du champ de distances à l’aide d’un <ADF>.
Un <ADF> est un <octree>, dont chaque nœud stocke huit distances, chacune correspondant à la
distance entre un des sommets du nœud et la primitive géométrique la plus proche 3 . La distance de
la primitive géométrique la plus proche peut être évaluée pour tout point à l’intérieur d’une cellule, à
partir d’une interpolation tri-linéaire des distances stockées pour les sommets.
La structure de données peut être construite par subdivisions successives des nœuds de l’<octree>, tant
qu’un critère de raffinement donné par un oracle n’est pas vérifié. L’oracle utilisé peut par exemple
comparer localement le champ de distances et son approximation linéaire encodée dans la cellule de
l’<ADF> : s’ils sont trop différents, la cellule est subdivisée. Un <ADF> peut également être obtenu
en partant d’un champ de distances à pleine résolution, et en fusionnant successivement les nœuds qui
possèdent un champ de distances homogène.
Comme nous le verrons dans la section 5, notre implémentation est basée sur cette structure de
données.
3 Génération automatique de graphes cellules-portails

3.1 Présentation de l’algorithme de <watershed>
Dans ce paragraphe, nous expliquons l’algorithme dans R2 ; il s’étend facilement aux espaces de
dimension supérieure, le <watershed> dans R3 en est par exemple une extension directe.
Soit la fonction scalaire f : R2 ! R , qui associe à tout point X (x; y) 2 R2 le scalaire d. Considérons
cette fonction f comme étant un champ de hauteurs S : R2 ! R 3 : z = d (x; y), et utilisons une analogie
hydrographique. pour définir les bassins versants et les lignes de partage des eaux de f . Cette
analogie consiste à percer un trou en chacun des minima locaux de la surface S, après quoi cette surface
3 Une structure de données similaire a également été proposée par Jung et al. dans le cadre de la robotique [89].
est plongée dans un lac avec une vitesse verticale constante. Au cours de ce processus, les vallées de
S sont inondées par l’eau entrant par les trous et créent les bassins versants Ri (Figure 6.2(a)). Au
fur et à mesure de la montée des eaux, les eaux issues de différents bassins risquent de se mélanger.
Pour éviter ces mélanges, un barrage est construit pour séparer les bassins sur le point de fusionner
(cf. Figure 6.2(b)). A la fin du processus, toute la surface est sous eau et seuls les barrages émergent ;
chaque bassin contient un et un seul minium local de f (cf. Figure6.2(c)).
(a) (b) (c)
F IG . 6.2: Différentes étapes de l’algorithme de <watershed>. Vue en coupe de la fonction f .
Le <watershed> de f est défini comme étant l’ensemble des barrages séparant les bassins versants.
Cet algorithme est souvent utilisé en segmentation d’images, en appliquant l’algorithme au gra-
dient d’une image. En effet, soit I une image en niveaux de gris, et grad (I ) son image gradient
associée. Si on applique un algorithme de <watershed> à grad (I ), les lignes de partage des eaux
correspondent aux contours de l’image et les bassins versants aux objets présents dans l’image I.
Remarque : Supposons que deux bassins Ra et Rb soient sur le point de se mélanger et que le
contact soit situé sur un plateau de S. Un barrage doit être construit pour séparer Ra et Rb , mais tout
le plateau constitue une région valide pour la construction du barrage, et il est nécessaire de décider
où le barrage sera placé. Dans l’algorithme classique de <watershed>, le barrage est placé sur le
<Geodesic Skeleton Zones of Influence>, noté <SKIZ> a .
a Définition du <SKIZ> (adaptée de [14]) : Considérons un ensemble de régions Y incluses dans une région X. La zone
i
d’influence de Yi est l’ensemble de tous les points de X qui sont à une distance géodésique finie de Yi et qui sont plus
proches de Yi que de n’importe quel autre point de Yj (cf. Figure 6.3). Le <SKIZ> est constitué des frontières entre les
zones d’influence de Y dans X. Le <SKIZ> peut être calculé par des dilatations successives de Yi dans l’ensemble X.
Le <watershed> de f est donc situé sur le <SKIZ> de la fonction f .
F IG . 6.3: <SKIZ> des régions Yi dans X.
3.2 Utilisation du <watershed> pour la génération de graphes cellules-portails

Soit b(x; y) une image représentant une scène architecturale, et soit d (x; y) le champ de distances
de cette image, chaque pixel de d (x; y) contenant un scalaire représentant la distance au pixel non
3 Génération automatique de graphes cellules-portails 129
blanc de b(x; y) le plus proche (cf. Figure 6.4). Dans cette section, nous montrons que l’algorithme
classique de <watershed> appliqué à d (x; y) permet de générer de manière automatique un graphe
<CPG>.
Remarque : Pour rester compatible avec l’analogie d’inondation présentée ci-dessus, le champ de
distances d est inversé (les distances reçoivent un signe négatif).
F IG . 6.4: Champ de distances représentant un modèle architectural (les distances les plus proches sont
représentées en blanc et les plus lointaines en noir).
La représentation du champ de distances d sous la forme d’un champ de hauteurs montre que
les selles de cheval de la surface correspondent aux ouvertures de la scène où nous souhaitons placer
les portails (cf. Figure 6.5). En 3D, ces emplacements correspondent aux pincements du champ de
distances.
F IG . 6.5: Le champ de distances d représenté comme un champ de hauteurs. Un point de selle, correspondant
à l’emplacement d’un portail, est mis en évidence.
La progression de l’algorithme de <watershed> appliqué au champ de distances d est représentée

sur la Figure 6.6.
Les résultats de cette segmentation sont proches de ceux de la subdivision intuitive décrite ci-
dessus (cf. la dernière image de la Figure 6.6) :
– les cellules correspondent grosso-modo aux bassins versants du champ de distances d. Il s’agit
de l’espace volumique délimité par la géométrie et séparé par les portails. On constate qu’ils
correspondent bien aux pièces des bâtiments architecturaux.
– les barrages séparent les bassins versants et correspondent aux portails. Ils sont placés aux
pincements de l’espace libre de la représentation volumique de la scène. En terme de visibilité,
F IG . 6.6: Différentes étapes de l’algorithme de <watershed>. Deux bassins versants entrant en contact lors
d’une itération révèlent la présence d’une ouverture : un portail est construit pour les s éparer.
ils correspondent aux zones dans lesquelles les segments libres maximaux (soit l’ensemble
des segments tracés entre les points mutuellement visibles de la scène) sont concentrés. Cela
signifie que les portails sont placés aux endroits supposés intéressants pour l’élimination des
objets cachés. De plus, dans les scènes architecturales, l’ensemble des pincements contient
effectivement l’ensemble des ouvertures (portes, fenêtres et corridors).
Notons qu’un portail est ajouté à chaque pincement et que chaque minimum local génère une
cellule. De ce fait, certains portails et certaines cellules peuvent être superflus. Ce problème est accru
lorsque la géométrie initiale est compliquée et crée un champ de distances très perturbé. Il s’agit
d’une illustration du problème classique de sur-segmentation qui survient lorsque l’on segmente une
image à l’aide d’un <watershed>. Dans le paragraphe 6, nous proposons pour ce problème différentes
solutions, adaptées à notre cas.
4 Implémentation
Nous proposons maintenant un algorithme de génération automatique de graphes cellules-portails
adapté de l’idée générale du <watershed>, et se déroulant en différentes étapes. Pour commencer, le
champ de distances est calculé et échantillonné dans une grille. Le champ de distances ainsi construit
est utilisé par le <watershed> pour trouver les points de contact entre bassins versants où les portails
sont placés sur base de la géométrie de la scène. Le graphe cellules-portails en lui-même est calculé
pendant le déroulement du <watershed>. A la fin de l’algorithme, la géométrie de la scène est associée
aux différentes cellules.
4 Implémentation 131
4.1 Etape 1 : Calcul du champ de distances

Du point de vue de l’algorithme de création de graphes <CPG>, la seule différence entre toutes les
techniques de modélisation (surfaces paramétriques, surfaces implicites, représentations volumiques,
maillages polygonaux) est le calcul du champ de distances, utilisé par l’algorithme de <watershed>.
Dans notre implémentation, nous utilisons un algorithme de <transformée de distances>, similaire à
celle présentée par Rosenfeld et al. [134], qui a l’avantage de ne pas compromettre le déroulement du
<watershed>. En effet, la transformée de distances ne déforme que localement le champ de distances,
sans ajouter ou supprimer de minima locaux : le nombre de régions et leurs formes globales sont
conservées. Lorsque le champ de distances exact est nécessaire, par exemple pour le placement du
portail (cf. paragraphe 4.3.1), il est calculé au vol depuis la représentation géométrique initiale.
Notons qu’une alternative intéressante pour calculer le champ de distances consisterait à utiliser
un algorithme rapide, tel que celui présenté récemment par Sud et al. [150]. Nous ne l’avons pas utilisé
car cet algorithme est apparu après le développement de notre méthode.
4.2 Etape 2 : Détection des portails

Cette phase correspond à l’algorithme de <watershed>. Soit h un scalaire et iso(h) l’iso-surface du
champ de distances définie par l’équation iso(h) d (x; y; z) = h. Cette iso-surface découpe l’espace
entre un volume intérieur V in tel que d (X ) < h pour tout X (x; y; z) 2 V in et un volume extérieur V out
pour lequel d (X ) > h pour tout X (x; y; z) 2 V out .
Pour simuler la montée de l’eau, l’algorithme consiste à partir d’une valeur minium pour h, puis à
augmenter cette valeur de manière itérative 4 . Soit t l’itération courante, h(t ) la valeur de h au temps
t, iso(h(t )) l’iso-surface correspondante, Vin (t ) le volume intérieur à cette iso-surface et Vout (t ) son
volume extérieur.
En t = 0, la hauteur h(0) est égale à la distance minimum stockée dans le champ de distances.
Au temps t, le volume intérieur V in (t ) est découpé en différentes régions Ri , chacune recevant un
identifiant unique li . Nous attribuons à chaque voxel du champ de distances un identifiant qui indique
la région à laquelle il appartient. Pour ce faire, nous utilisons un algorithme d’étiquetage, qui part d’un
voxel de Ri et propage l’identifiant li à tous ses voxels connexes, puisque ces voxels appartiennent par
définition à la région Ri 5 .
L’étape clé de l’algorithme de détection des portails consiste à détecter les bassins versants qui
fusionnent durant l’itération t, afin de les séparer par un barrage. Cette tâche est accomplie au début
de l’itération t, par la dilatation de chacune des régions de Vin (t 1) au sein de l’espace de V in (t ). La
dilatation est réalisée à l’aide d’un algorithme de remplissage 6 : chaque région Ri est considérée tour à
tour, et l’identifiant li correspondant est propagé à l’ensemble des voxels connexes à Ri , et appartenant
au volume V in (t ) (cf. Figure 6.7). Soit lold l’identifiant stocké dans un voxel rencontré au cours de la
dilatation de la région Ri .
Trois cas de figure sont possibles :
– lold n’est pas initialisé : la dilatation de la région a atteint un voxel vide auparavant. Rien ne se
passe et la dilatation continue (cf. Figure 6.7 (b)).
– li = lold : le voxel appartient déjà à la région, et la propagation s’arrête.
4 Pour rappel, nous avons inversé le champ de distances pour rester compatible avec l’analogie d’inondation.
5 Pour définir l’ensemble de voxels appartenant à une même région, nous utilisons une <4-connectivité> en 2D et une
<6-connectivité> en 3D.
6 Algorithme <floodfill> en anglais.
– li 6= lold : le voxel appartient déjà à une autre région (cf. Figure 6.7 (d)). Les deux régions Rold
et Ri sont en contacts. Elles sont restaurées dans la configuration géométrique qu’elles avaient
avant la dilatation, Ri (t 1) et Rold (t 1) et un portail (barrage) est construit pour les séparer
(cf. section 4.3). Le processus de dilatation recommence après l’ajout du barrage (cf. Figure6.7
(e) et (f)).
Itération t 1
(a) avant dilatation (b) après dilatation
Itération t
(c) avant dilatation (d) pendant dilatation.
Itération t
(après la construction du barrage)
(e) avant dilatation (f) après dilatation
F IG . 6.7: Propagation de l’identifiant pour la d étection de portails.
4.3 Etape 3 : Création des portails

Le <SKIZ>, où les barrages sont construits dans le <watershed> classique, ne sont pas adaptés
comme portails. Tout d’abord, il est entièrement dépendant de la forme de la région, et il n’y a au-
cune garantie que le <SKIZ> touche la géométrie initiale. Ensuite, le <SKIZ> est un ensemble 3D de
voxels qui ne convient pas pour l’élimination efficace des objets masqués.
A la place, nous définissons un barrage comme étant un rectangle appartenant à un plan orienté,
situé sur le pincement du champ de distances et entourant les primitives géométriques ayant occa-
sionné le pincement. Dans le champ de distances, tous les voxels traversés par le portail sont marqués
comme faisant partie d’un barrage et constituent un obstacle : les algorithmes de propagation utilisés
dans l’étape 2 (c-à-d. les algorithmes d’étiquetage et de dilatation) ne peuvent les traverser. Cette
définition des barrages est la différence la plus importante entre notre algorithme et le <watershed>
classique.
Quand un point de contact a été découvert entre deux régions Ra and Rb , nous construisons un
portail pour les séparer. Nous utilisons pour ce faire successivement deux procédures, l’une étant
mieux adaptée aux portails <épais> et l’autre aux portails <minces> : le plus petit portail généré est
conservé. La première méthode de positionnement, présentée à la section 4.3.1, utilise uniquement
le champ de distances ; la seconde, présentée à la section 4.3.2, est basée sur un procédé d’analyse
d’images.
4.3.1 Positionnement basé sur le champ de distances

Juste avant de commencer le processus de positionnement, le volume Vin (t 1) des deux régions à
séparer a été restauré. Cela permet de calculer une estimation du portail à partir du champ de distances.
Le plan contenant le portail est défini par sa normale n et par un point de passage M :
– Intuitivement, une bonne direction pour n est donnée par le squelette 7 du champ de distances
qui traverse le portail [85]. Il peut être approché localement par le segment joignant les deux
points les plus proches (noté C1 et C2 ) de l’iso-surface des régions Ra et Rb à l’itération (t
1). La distance utilisée est la distance géodésique 8 . En pratique, cela signifie que le segment
C1C2 ne peut pas traverser la géométrie de la scène pour être valide. Dans le cas montré à la
Figure 6.8(a), la distance euclidienne donnerait le segment XY , à la place du segment correct
C1C2 .
– Par convention, nous choisissons de placer M au milieu du segment C1C2 .
Nous utilisons la procédure suivante pour les points C1 et C2 (cf. Figure 6.8(b)). En partant du
point de contact P entre les deux régions, nous cherchons B1 qui est le point de l’iso-surface entourant
la région Rb le plus proche de P. Ensuite nous cherchons le point le plus proche de B1 et situé sur
l’iso-surface entourant la région Ra : il s’agit de C1 . Finalement, nous trouvons C2 , qui est le point
de Rb le plus proche de C1 . Cette procédure assure que nous trouvions le pincement correct lorsqu’il
existe plusieurs pincements de taille égale entre Ra et Rb (cf. Figure 6.8(b)).
(a) (b) (c)
F IG . 6.8: (a) Utilisation de la distance g éodésique : le segment joignant les deux points les plus proches ne peut
pas traverser la géométrie. (b) Calcul de C1 et de C2 . Dans ce cas simple, B1 est égal à C2 . (c) Le positionnement
du portail à l’aide du champ de distances échoue quand le champ de distances est bruit é et que la géométrie
sur laquelle doit s’appuyer le portail est mince.
7 Dans ce chapitre, le squelette est utilisé au sens de l’analyse d’images. Le squelette d’un objet est défini comme étant
le lieu des centres de toutes les sphères de rayon maximum inscrites dans l’objet.
8 Soit X et Y deux points de l’ensemble X . La distance géodésique entre X et Y est la longueur du plus petit chemin
inclus dans X et reliant X et Y .

Cet algorithme de positionnement peut échouer si le portail est fin, car il n’y a pas de garantie
que le segment C1C2 donne une orientation correcte (cf. Figure 6.8(c)). C’est pourquoi nous avons
développé un second algorithme de positionnement dans le cas des portails fins, qui est présenté dans
la section suivante.
4.3.2 Positionnement basé sur un procédé d’analyse d’images

L’algorithme consiste à faire reposer le portail sur la géométrie responsable du pincement en
s’aidant d’un procédé d’analyse d’images. Les images sont générées à l’aide d’une caméra virtuelle
avec un large champ de vue, placée en C1 et pointant dans la direction de C2 . Un quadrilatère de
taille arbitrairement grande est placé en C2 , perpendiculairement à C1C2 . Ce quadrilatère est dessiné
en rouge, puis la géométrie de la scène est dessinée en blanc. L’image obtenue est analysée pour
déterminer la direction du portail. Le point central de l’image appartient au portail puisque celui-ci
possède une intersection avec la droite C1C2 : la région rouge de l’image qui contient ce point central
est sélectionnée, et sa silhouette extérieure définit approximativement le contour du portail. Chacun
des pixels de ce contour est replacé dans R3 , à l’aide d’une opération de rétro-projection 9 et forment
ensemble un nuage de points. Nous calculons l’équation du meilleur plan contenant l’ensemble des
points de ce nuage, au sens des moindres carrés, et la normale n définit la direction du portail.
4.3.3 Taille du portail

Après l’utilisation de ces deux algorithmes de positionnement, nous disposons de la position du
plan contenant le portail. Le portail étant un rectangle, nous devons maintenant calculer sa taille,
c’est-à-dire la longueur de ses côtés. Pour ce faire, nous utilisons également un procédé d’analyse
d’images virtuelles, et plaçons une caméra, avec un champ de vue de 90 degrés au centre M du
portail, et pointant dans une direction située dans le plan du portail. Cette caméra est utilisée pour
calculer successivement quatre vues de la scène, une rotation de 90 degrés autour de la direction n
étant appliquée à la caméra entre chaque calcul de vue. Nous obtenons de la sorte quatre vues de la
géométrie entourant le portail, prises depuis le centre de ce dernier. Par construction, l’intersection
du plan contenant le portail et chacune de ces vues est une ligne de pixels, qui traverse l’image en
son centre. Nous replaçons l’ensemble des pixels de cette ligne centrale dans R3 , à l’aide du procédé
de rétro-projection, et obtenons un nuage de points coplanaires, appartenant tous au plan du portail.
Le rectangle définissant le portail est le plus petit rectangle orienté les entourant, calculé à l’aide
d’un calcul en composantes principales. Une amélioration (non implémentée) serait de découper ce
rectangle par rapport à la géométrie de la scène, afin de créer des portails plus complexes, dont les
bords seraient plus proches de la géométrie de la scène et qui permettraient d’éliminer les objets
masqués de manière moins conservative.
4.4 Etape 4 : Création des cellules

Les cellules sont les espaces volumiques discrétisés, entourés par la géométrie et séparés par
les portails. Elles ne sont pas nécessairement convexes. La résolution du champ de distances fixe la
9 Rétro-projeter le pixel p(i; j) d’une image consiste à calculer les coordonnées du point P(x; y; z) 2 R3 qui a été projeté
sur le pixel p(i; j). Cette opération est réalisable en récupérant la profondeur du pixel, z(i; j), stockée dans le z-buffer de
l’image, et en appliquant au triplet (i; j; z(i; j)) l’inverse des opérations mathématiques effectuées pour projeter le point P
dans l’image. De manière concrète, il s’agit d’appliquer au triplet (i; j; z(i; j)) la matrice (PM ) 1 , qui est la matrice inverse
de la matrice PM (P étant la matrice de projection et M étant la matrice de positionnement de la caméra).
taille de la plus petite pièce que l’algorithme est capable de trouver : la résolution doit être choisie
suffisamment fine pour qu’il y ait au moins un voxel dans chacune des pièces.
La correspondance entre les primitives géométriques de la scène et les bassins versants issus du
<watershed> n’est pas immédiate : comme on peut le voir à la Figure6.9(a), la géométrie ne se situe
dans aucun bassin versant à la fin du <watershed>, puisque par définition, les primitives géométriques
séparent les bassins versants. Dans notre implémentation, chaque primitive géométrique est assignée
à son bassin versant le plus proche, dans la direction de sa normale. Pour le trouver, nous prenons
quelques points de manière aléatoire sur la surface de la primitive, et recherchons le bassin le plus
proche de chacun d’entre eux. Un vote majoritaire est ensuite effectué pour assigner la primitive à la
cellule la plus proche.
Remarque : Les primitives géométriques qui traversent plusieurs portails ne sont assignés qu’à une
et une seule cellule : cela n’est pas nécessaire de les assigner aux deux cellules connectées par le
portail, puisque ces primitives seront toujours considérées comme visibles au travers du portail et
toujours affichées.
(a) (b)
F IG . 6.9: (a) Création des cellules : les primitives géométriques constituant la scène sont associées à leur
bassin versant le plus proche. (b) Localisation de la cam éra : contrairement à la caméra 2, la caméra 1 est
correctement localisée car le rayon ne traverse pas de portails avant de toucher la g éométrie.
4.4.1 Localisation de la caméra

Le stockage de la description géométrique des cellules est nécessaire afin de localiser la caméra
pendant l’exploration interactive. Malheureusement, chaque solution a des inconvénients :
– une description volumique est bien adaptée pour la localisation mais son coût mémoire est très
important.
– la représentation exacte de la surface (extraite à l’aide d’un algorithme de <marching cubes>
par exemple) nécessiterait beaucoup de polygones et ne serait pas très efficace pour localiser la
caméra.
– le stockage à l’aide d’un arbre <BSP> résoudrait le problème de la localisation mais le coût
mémoire ne serait pas négligeable et la construction d’un bon arbre <BSP> n’est pas évidente.
Plutôt que de stocker une description explicite, notre implémentation utilise un stockage impli-
cite. Chaque primitive géométrique stocke un identifiant indiquant la cellule du graphe à laquelle elle
appartient, et en retour chaque cellule du graphe contient la liste des primitives géométriques qui la
composent, organisée dans un arbre hiérarchique pour accélérer l’élimination des objets masqués au
cours de la navigation interactive 10 . Au début de la phase de visualisation, la caméra est localisée
en lançant un rayon depuis le point de vue à travers la scène (cf. Figure6.9(b)). Si un portail est tra-
versé avant qu’un objet ne soit rencontré par le rayon, d’autres rayons sont lancés dans des directions
aléatoires (cette situation peut être facilement évitée en utilisant des rayons verticaux, car une scène
typique ne contient pas beaucoup de portails horizontaux). Pendant le reste de la visualisation, les
changements de cellules sont simplement détectés lorsque la caméra traverse un portail durant son
déplacement.
5 Implémentation hiérarchique
Dans les scènes dont l’espace navigable est étendu, la mémoire nécessaire pour stocker le champ
de distances devient problématique et sa compression est nécessaire. En pratique, c’est pour cette
raison que nous n’avons pas implémenté l’algorithme décrit ci-dessus sur une grille régulière. A la
place, nous avons utilisé les <Adaptively Sampled Distance Fields> notés <ADF> [64]. Pour rappel,
un <ADF> est un <octree>, dont chaque nœud stocke la distance entre la géométrie et chacun de
ses 8 sommets. La distance à la géométrie d’un point situé à l’intérieur d’une cellule est calculée par
interpolation tri-linéaire des distances stockées pour les sommets.
La construction de l’<ADF> commence par le calcul du champ de distances à la résolution la plus

grande, en utilisant un calcul de distances du type de celui présenté dans [134]. Ensuite l’<octree>
est obtenu en fusionnant les portions linéaires du champ de distances. La décision de fusionner des
nœuds de l’<octree> est prise par un oracle, qui assure que les détails ne sont conservés que là où
cela est nécessaire. Pour la génération de <CPG>, les zones d’intérêt, où il est intéressant de raffiner
l’<octree>, sont les pincements et les excroissances du champ de distances, qui définissent la position
des portails. Les deux correspondent à des zones où le champ de distances est non-linéaire. C’est
pourquoi notre oracle ne fusionne pas les nœuds si l’interpolation linéaire donne de mauvais résultats
en comparaison avec les valeurs de distances exactes. Le taux d’erreur accepté par l’oracle doit être
choisi suffisamment petit pour être sûr que notre algorithme ne rate pas de pièces du bâtiment à cause
de la représentation à base de l’<ADF>. Intuitivement, un seuil bas impose que le squelette du champ
de distances, qui passe par les portails et le centre des pièces, soit raffiné à la profondeur maximum.
Soit n un nœud de l’<octree>. En plus des huit distances correspondant à la distance aux sommets,
nous stockons également une distance minium et maximum pour le nœud n, que nous notons min(n)
et max(n). Pour une feuille de l’arbre, ces valeurs correspondent à la valeur minimum (respectivement
maximum) de ses 8 distances. Pour un nœud intermédiaire, ces valeurs correspondent à la distance
minimum (respectivement maximum) des distances de tous les nœuds enfants.
Soit iso(h) l’iso-surface définie par l’iso-valeur h et Vin et V out les volumes intérieur et extérieur
à cette iso-surface. Les valeurs min(n) et max(n) suffisent pour la majorité des opérations sur le nœud
n. Par exemple :
– n appartient à V in si max(n) < h
– n appartient à V out si min(n) > h
– n contient une portion de iso(h) si min(n) <= h et max(n) >= h
Outre la compression obtenue en stockant le champ de distances à l’aide d’un <ADF>, l’aspect
multi-résolution est l’avantage principal de cette structure de données. L’algorithme de création de
10 Nous utilisons un arbre binaire de boı̂tes alignées par rapport aux axes.
6 Sur-segmentation 137
<CPG> en lui-même est très similaire à la version basée sur la grille régulière. Seule l’étape de
découverte des portails est modifiée pour bénéficier de sa structure hiérarchique :
– les valeurs min(n) et max(n) stockées en chaque nœud n permettent d’accélérer les algorithmes,
en éliminant rapidement les portions de l’<octree> qui ne sont pas concernées par un traitement.
– au sein de l’<octree>, la navigation entre les nœuds voisins n’est pas aussi évidente que dans
le cas d’une grille régulière et des algorithmes permettant de se déplacer entre nœuds voisins
doivent être utilisés [78] [15] [64]. Notre implémentation utilise l’algorithme présenté par Par-
thajit Bhattacharya [15].
Remarque : Dans notre implémentation, les huit distances ne sont pas stockées, afin d’économiser
de la mémoire vive, et les calculs sont exclusivement basés sur min(n) et max(n). Lorsqu’une distance
précise est requise (par exemple pour le placement d’un portail), nous n’utilisons pas la distance
interpolée à partir de l’<ADF> mais nous la calculons à la demande, à partir de la géométrie initiale.
6 Sur-segmentation
En traitement d’images, la segmentation par <watershed> est connue pour être sensible au bruit :
ce dernier crée beaucoup de minima locaux et chacun d’entre eux devient un bassin versant durant le
déroulement de l’algorithme. Comme résultat, de nombreuses régions sont créées ; le phénomène est
connu sous le nom de sur-segmentation 11 .
Dans le cas de la génération de graphes cellules-portails, la sur-segmentation survient quand le
champ de distances présente beaucoup de minima locaux (typiquement dans le cas de pièces meublées,
de murs en zig-zag,...). Le modèle est alors découpé en un grand nombre de cellules séparées par des
portails redondants. Pour résoudre ce problème, deux approches sont possibles [112]. La première
consiste à prétraiter les données, afin de réduire le bruit et d’éliminer les minima locaux avant l’al-
gorithme de <watershed>. La seconde consiste à traiter les résultats a posteriori, en fusionnant les
régions sur-segmentées à l’aide d’une heuristique donnée.
Dans ce paragraphe, nous proposons deux prétraitements qui résolvent le problème de la sur-
segmentation dans la majorité des cas observés. Le premier consiste à éliminer les détails de la scène
(cf. section 6.1) et le second consiste à voxeliser la scène avant de calculer le champ de distances (cf.
section 6.2).
6.1 Elimination des détails

L’élimination des détails consiste à enlever les objets qui ne sont pas importants pour la détermi-
nation de la visibilité, tels que les meubles, lors de la phase de construction des <CPG>, et a les ajouter
ensuite aux cellules à la fin du processus. Il s’agit d’une méthode classique, utilisée par exemple
par Seth Teller [154], qui détecte automatiquement les détails en mesurant la taille de chacun des
objets et en ne conservant que les objets suffisamment grands pour le calcul de la visibilité. Cette
approche peut être vue comme un filtrage de la géométrie, et fournit en pratique de bons résultats.
Nous utilisons une approche manuelle, qui consiste à marquer explicitement les objets que l’on ne
considère pas comme relevants pour la construction du <CPG>. Cette simplification ne requiert que
peu de travail supplémentaire lors de l’étape de modélisation, mais elle peut s’avérer contraignante
lorsqu’elle n’est pas couplée à l’étape de modélisation. C’est pourquoi nous proposons d’utiliser une
11 La sur-segmentation est l’<over-segmentation> en anglais.
étape de voxelisation comme traitement complètement automatisé afin de réduire le bruit présent dans
le champ de distances.
6.2 Voxelisation robuste

Une représentation volumique binaire de la scène peut être utilisée comme support pour le calcul
du champ de distances, à la place de la géométrie initiale de la scène. Pour des ensembles de tri-
angles indépendants, nous utilisons un algorithme de voxelisation robuste que nous avons développé
dans des travaux précédents [81]. Cet algorithme a été conçu pour traiter tout type de scènes, même
celles contenant des dégénérescences comme des doubles murs, des maillages s’interpénétrant, des
interstices ou des trous. La représentation volumique obtenue est propre et ne présente pas tous ces
problèmes :
– le bruit dû aux dégénérescences est éliminé.
– la voxelisation agit comme un filtre passe-bas, la taille des voxels fixant la taille des détails qui
sont éliminés (les murs doivent être suffisamment larges pour faire partie de la représentation
volumique). Ce filtrage élimine donc de nombreux minima locaux.
– la représentation volumique permet de calculer une distance signée, puisqu’elle distingue l’inté-
rieur et l’extérieur des objets : les régions intérieures ne doivent plus être traitées par l’algo-
rithme de <watershed>.
Pour toutes ces raisons, la voxelisation constitue un prétraitement automatique efficace de la scène,
qui élimine en grande partie la sur-segmentation et les problèmes éventuels de modélisation.
7 Résultats
Nous avons implémenté l’algorithme hiérarchique de création de cellules-portails et l’avons testé
sur différents types de scènes pour démontrer sa généralité. Toutes les expériences on été réalisées sur
un ordinateur Pentium 3 cadencé à 800 Mhz, et équipé de 512 Mo de mémoire vive et d’une carte
graphique <GeForce 2 GTS>.
7.1 Etude qualitative des graphes générés

La première scène est une scène architecturale d’une maison (47k triangles) disponible sur le site
de la firme Hybrid Graphic12 . Ce modèle est particulièrement intéressant car il est utilisé dans leur
produit commercial de visibilité <dPVS>, comme démonstration de l’utilisation de graphe cellule-
portails pour accélérer l’affichage de scènes. Un graphe <CPG>, créé à la main, est joint au modèle
et peut directement être comparé à celui obtenu à l’aide de notre algorithme. Avant de calculer le
champ de distances, nous avons enlevé les portes et les fenêtres avec un logiciel de modélisation,
ainsi que les meubles pour éliminer la sur-segmentation. Notre algorithme a ensuite été utilisé pour
créer une décomposition <CPG>. Le résultat est très proche de l’original et contient tous ses portails
(cf. Figure 6.10). La seule différence sont les portails ajoutés par notre algorithme sur les fenêtres
extérieures et un portail ajouté dans le corridor central.
Ce travail a été effectué partiellement en collaboration avec la firme de jeu vidéo <Appeal>. Les
deux scènes suivantes, que nous avons déjà utilisées dans le chapitre5, proviennent de leur jeu <Out-
cast 2>. Ces scènes contiennent de nombreuses dégénérescences, principalement dues au procédé de
modélisation basé sur la duplication de géométrie : la scène est modélisée à partir de quelques objets
12 http ://www.hybrid.fi/main/download/demos.php
7 Résultats 139
(a) (b)
F IG . 6.10: Scène (a) - Modèle architectural utilisé par <dPVS>. (a) Cellules créées par notre algorithme. (b)
Quelques-uns des portails créés par notre algorithme (scène traitée sans les meubles, qui ont été ajoutés aux
cellules à la fin du processus).
de base, qui sont répliqués avec des facteurs d’échelle et des paramètres de distortions pour créer de
la variété. Même si ce procédé de duplication est un moyen efficace pour réduire le coût mémoire, il
introduit des artéfacts : objets s’interpénétrant, des interstices et des trous. Si l’on ne tient pas compte
de ces dégénérescences, le champ de distances serait très bruité, et contiendrait de nombreux minima
locaux non intéressants. Pour cette raison, nous avons appliqué une étape de voxelisation, destinée à
filtrer les détails et les artéfacts avant de créer le <CPG>.
La scène (b) est une maison composée de 47k triangles. Pour ce modèle, notre algorithme trouve
correctement toutes les portes en forme d’arches et traite correctement le centre de la pièce faite de
piliers parallèles (cf. Figure 6.11).
(a) (b)
F IG . 6.11: Scène (b) - Maison, contenant de nombreuses d égénérescences. (a) Décomposition obtenue. (b) La
pièce centrale, faite de piliers successifs. Cette scène a été traitée après une étape de voxelisation.
La scène (c) est un paysage de pierre contenant des pièces souterraines (281k triangles), et représen-
te un mélange de scènes d’intérieur et d’extérieur en 3D. L’algorithme crée un graphe <CPG> pour
la partie intérieure (les pièces souterraines), et ne subdivise pas la partie extérieure qui n’est pas bien
adaptée pour un rendu par cellule-portail (cf. Figure 6.12). La raison est que le processus d’inonda-
F IG . 6.12: Scène (c) - Modèle comportant une partie architecturale et une partie ext érieure, contenant de
nombreuses dégénérescences. L’algorithme crée un graphe <CPG> pour les pi èces souterraines, mais ne traite
pas le reste de la scène (cette scène a été traitée après une étape de voxelisation).
tion démarre aux endroits fermés, qui constituent des minima locaux. Quand aucun minimum de cette
sorte n’existe, une seule région est créée et aucun portail n’est ajouté. Dans le cas de la visualisation
de terrains et de villes 2D 12 , quelqu’un pourrait vouloir utiliser un graphe <CPG>, avec les portails
placés entre les différents bâtiments [101]. Pour étendre le processus de création de <CPG> à ce type
d’environnements, une solution simple consiste à calculer un <watershed> 2D sur le champ de hau-
teurs 2D, pour lequel les minima existent effectivement. Une autre solution pourrait consister à ajouter
manuellement, à l’aide d’un outil interactif, les minima locaux de manière artificielle dans le champ
de distances.
La scène (d) est le <Soda Hall> de Berkeley (sans les meubles), qui compte 18k triangles13 , et qui
a été traitée sans aucun prétraitement. L’algorithme trouve toutes les pièces, les portes et les fenêtres
du bâtiment (cf. Figure 6.13). Un problème non résolu est le traitement des lignes de selle de cheval
du champ de distances, qui traverse typiquement les corridors. Notre méthode place un seul portail
au milieu d’une telle ligne, mais un gain en élimination d’objets pourrait être obtenu en plaçant des
portails au début et à la fin de la ligne de selle (c-à-d le début et la fin du corridor).
13 http ://www.cs.berkeley.edu/ sequin/soda/soda.html
7 Résultats 141
F IG . 6.13: Scène (d) - Modèle architectural du <Soda Hall>. Dans un b âtiment, l’algorithme <trouve> toutes
les pièces, les portes et les fenêtres.
La dernière scène est un modèle médical utilisé en endoscopie pulmonaire virtuelle et représentant
un modèle de bronches humaines (49K triangles)14 . Les résultats montrent que l’algorithme est ca-
pable de générer des graphes <CPG> pour les environnements tubulaires (cf. Figure6.14).
F IG . 6.14: Scène (e)- Modèle de bronches humaines : d écomposition obtenue à l’aide de l’algorithme de
création automatique de graphes cellules-portails.
Mesurer la qualité des résultats est une tâche difficile car peu de points de comparaison existent :
la génération de graphe <CPG> est souvent effectuée à la main et à notre connaissance, aucune des
méthodes automatiques publiées précédemment ne peut traiter de scènes quelconques. Les résultats
pourraient être comparés avec ceux obtenus à l’aide d’une décomposition <BSP> pour le modèle le
plus simple (scène (d)). Malheureusement, ce type de décomposition n’est pas évident à créer pour
les autres scènes, contenant des dégénérescences et des centaines de milliers de triangles. De plus, il
n’est pas certain qu’une décomposition <BSP> soit capable de traiter des scènes tubulaires comme des
bronches humaines. Dans ce contexte, nous n’avons comparé nos résultats qu’à des décompositions
14 http ://www.cc.nih.gov/drd/endoscopy.htm
créées à la main, même si elles ne sont pas optimales en termes de visibilité. Pour chacune de nos
scènes de test, cette comparaison montre que la méthode de décomposition automatique trouve tous les
portails <classiques>, mais ajoute également des portails redondants à cause de la sur-segmentation.
Comme travail futur, un post-traitement pourrait être implémenté pour les détecter et les supprimer.
7.2 Statistiques concernant la génération des graphes

Le nombre de cellules et portails des différentes décompositions, ainsi que le temps de calcul
pour les différentes étapes de l’algorithme sont résumés dans le tableau6.1. Le reste du tableau donne
des informations à propos du coût mémoire du champ de distances, la dernière colonne indique le
taux de compression obtenu en utilisant un <octree> à la place d’une grille 3D régulière. La grille
considérée est la plus petite grille contenant toute la scène, à la même résolution que l’<octree> et
contenant toutes les variables nécessaires pour notre implémentation de l’algorithme de <watershed>.
Le taux de compression est bon dans les scène creuses (scène 3) mais décroı̂t lorsque la géométrie
de la scène est distribuée de manière plus uniforme (scène 4). Dans ce cas, l’<octree> est raffiné
quasiment partout à la profondeur maximum : le coût de calcul est haut et le coût de mémoire est
encore un problème. L’algorithme pourrait être adapté pour traiter le problème région par région et
combiner les <CPG> créés pour les différentes régions dans une étape finale.
Scène a b c d e
Nombre de portails 33 25 13 402 30
Nombre de cellules 31 18 22 511 49
Temps de voxelisation - 8 min. 45 min. - 30 s.
Calcul du champ de distances (sec.) 7 20 129 73 62
Création de l’<octree> (sec.) 14 21 82 140 35
Détection des portails (sec). 154 18.5 182 > 2 heures 80
Positionnement des portails (sec.) 27 27.5 45.4 > 2 heures 39.6
Création des cellules (sec.) 30 2.2 102 4 2
Profondeur de l’<octree> 8 8 10 9 9
Coût mémoire (Mo) 14 47 90 224 32
Taux de compression 6/1 6/1 21/1 5/1 30/1
TAB . 6.1: Statistiques de création des graphes <CPG> dans les diff érentes scènes.
7.3 Utilisation du <CPG> pour l’<occlusion culling>

Une indication de la qualité du graphe cellules-portails est donnée par les accélérations obtenues
quand on utilise le graphe <CPG> pour afficher la scène. A cette fin, nous avons implémenté un algo-
rithme simple d’<occlusion culling> par cellules-portails. Cet algorithme fonctionne en ligne, durant
la phase de navigation interactive. Tout d’abord, la cellule dans laquelle la caméra se trouve est iden-
tifiée, et tous les objets de cette cellule sont considérés comme étant potentiellement visibles. Ensuite,
l’algorithme parcourt récursivement toutes les cellules qui sont connectées à la cellule courante par
un portail. Pour chaque portail rencontré, nous construisons un volume de vue simple, représentant la
région de l’espace visible au travers de l’ouverture. Nos portails étant des rectangles plans, ce volume
de vue est une pyramide semi-infinie, dont le sommet est le centre optique de la caméra s’appuyant
sur les arêtes du portail. Nous utilisons ensuite un test géométrique pour éliminer les objets situés à
8 Conclusions et perspectives 143
l’extérieur de ce volume de vue. Les objets de chaque cellule étant regroupés hiérarchiquement avec
un arbre de boı̂tes alignées avec les axes, nous utilisons l’algorithme présenté par Assarsson et al. [9]
pour tester si une boı̂te alignée possède une intersection avec le volume de vue.
Remarque : Un nouveau cône de vue est construit pour chaque portail rencontré : notre
implémentation ne tient pas compte des rétrécissements successifs à travers une séquence de por-
tails et est donc conservative.
Nous avons enregistré des chemins représentatifs à travers les scènes et avons mesuré les temps
d’affichage pour chaque scène de test. Le tableau6.2 compare le nombre d’images par seconde obtenu
en affichant toute la scène (colonne <Naı̈f>), en ne considérant que les objets dans le champ de la
caméra (colonne <CC> pour <Champ Caméra>) et en utilisant l’algorithme d’affichage exploitant le
graphe cellules-portails généré (colonne <CPG>).
Images/sec.
Naı̈f CC CPG
Scène min. moy. max. min. moy. max. min. moy. max.
a 7.5 8 8.5 8.5 58.9 753 23.2 188.2 1816
b 24.4 33 40.2 48.2 211 757 155 718 1650
c 6.66 7.4 7.8 13 46.1 168 183 561 1672
d 31 52 61 67 774 1632 597 1610 3170
e 16 23 26 34 156 485 42 345 2193
TAB . 6.2: Nombre d’images par seconde dans les diff érentes scènes, en fonction du type d’affichage utilis é.
Les facteurs d’accélération observés entre la méthode <CC> et la méthode <CPG> sont de l’ordre
de 2 3 pour la majorité des scènes et vont jusqu’à un facteur 12 pour la scène (d). Même si
cela ne prouve pas que la décomposition obtenue est optimale, cela montre que cette méthode de
décomposition automatique peut être utilisée dans un scénario de visualisation interactive pour amé-
liorer le temps d’affichage.
8 Conclusions et perspectives
Dans ce chapitre, nous avons proposé d’adapter l’algorithme classique de <watershed> pour
générer des graphes cellules-portails de manière automatique. Les résultats obtenus montrent que cette
approche permet d’obtenir un graphe CPG proche de la décomposition classique, qui était souvent
générée à la main dans le passé faute d’algorithmes appropriés. Nous avons également montré qu’elle
permettait de traiter des scènes variées, sans imposer de contraintes particulières de modélisation.
La mise en place de cette approche a soulevé différents problèmes, auxquels nous avons apporté
une première réponse, mais ils mériteraient cependant de plus amples investigations.
Le premier d’entre eux est le placement précis des portails. Nous avons proposé deux solutions, l’une
basée sur le champ de distances et la seconde basée sur un algorithme d’analyse d’images, mais elles
pourraient certainement être améliorées et rendues plus robustes. Dans le même ordre d’idée, il se-
rait intéressant d’utiliser des portails plus complexes que des rectangles orientés afin d’approcher la
géométrie de la scène de manière plus fidèle et de diminuer la sur-conservativité.
La seconde problématique à approfondir est celle de la sur-segmentation, qui apparaı̂t en présence

de bruit dans le champ de distances. Pour la réduire, nous avons proposé deux prétraitements, l’un
basé sur l’élimination manuelle des détails géométriques et l’autre sur une voxelisation de la scène.
Les effets de ces prétraitements sont encore à étudier de manière systématique, pour en mesurer les ef-
fets exacts. Une autre piste pour l’élimination de la sur-segmentation serait d’utiliser un <watershed>
marqué, souvent employé à cet effet en analyse d’images [133].
Les temps de calcul de l’algorithme de <watershed> hiérarchique utilisé pour générer le graphe
sont relativement réduits dans la majorité des scènes. Ils peuvent malgré tout devenir importants
lorsque la taille du champ de distances augmente (scène (d) par exemple). Un axe de recherche se-
rait de remplacer l’implémentation hiérarchique par une implémentation optimisée pour les grilles
régulières, telle que celle proposée par Felkel et al. [62]. Toutefois, en raison du coût mémoire impor-
tant que ce type d’approche impliquerait dans les scènes étendues, elle ne serait viable que si la scène
était subdivisée en différentes parties, qu’un graphe CPG était généré pour chacune d’entre elles et
que les résultats obtenus étaient combinés pour obtenir le graphe complet.
Finalement, il est difficile d’évaluer la qualité des résultats obtenus, car la définition d’un graphe
CPG optimum est encore une question ouverte [101]. Malgré tout, il serait intéressant d’estimer
l’efficacité des graphes que nous avons générés, à l’aide d’une technique similaire à celle proposée
récemment par Lerner et al. [101] 15 . De plus, cette évaluation permettrait de détecter les zones com-
portant trop de portails afin d’éliminer ceux qui sont superflus. Egalement dans l’optique d’optimiser
le nombre de portails, une méthode alternative consisterait à détecter les portails inutiles à l’aide
d’heuristiques semblables à celle proposée par Lefebvre et al. [99].
15 Lerner et al. évaluent le coût d’utilisation d’un graphe cellules-portails à l’aide d’un procédé d’échantillonnage : un
grand ensemble de points de vue est choisi de manière aléatoire dans chaque cellule, et le gain d’utilisation est évalué en
chacun de ces points.
Conclusions et perspectives
chapitre 7
Dans ce travail, nous avons étudié la problématique de l’élimination efficace des objets masqués,
en vue d’accélérer l’affichage de scènes complexes. Nous nous sommes plus particulièrement intéressé
aux méthodes de précalcul, qui effectuent les calculs coûteux de visibilité durant une phase de prétraite-
ment et les réutilisent lors de la phase de navigation interactive. Comme nous l’avons vu dans l’état
de l’art, les méthodes permettant un précalcul complet et exact sont encore hors de portée, c’est pour-
quoi des techniques approchées sont utilisées en pratique. Nous avons proposé dans ce document trois
méthodes originales de ce type. Nous résumons ici leurs principales caractéristiques et mettons en
évidence les perspectives d’application de chacune d’entre elles.
La première méthode, présentée dans le chapitre 3, est un algorithme exact de calcul de visibilité
depuis une région, permettant d’éliminer la sur-conservativité due à la méthode. Il se présente sous
la forme d’une requête de visibilité entre deux polygones. Nos contributions principales ont été de
simplifier cette requête, tant du point de vue théorique que du point de vue de l’implémentation, ainsi
que d’accélérer leur temps moyen d’exécution à l’aide d’un ensemble de techniques d’optimisation.
Il en résulte un algorithme plus simple à mettre en oeuvre et beaucoup plus rapide que les algorithmes
exacts publiés précédemment. Cette requête est une <brique> de base, qui peut être utilisée par n’im-
porte quel algorithme de précalcul de visibilité de plus <haut> niveau, tel qu’un algorithme de calcul
de PVS par exemple. Nous espérons que son développement aboutira à la mise au point de techniques
d’élimination des objets masqués dans les scènes complexes. Outre l’accélération de l’affichage, une
autre application majeure des algorithmes exacts consiste à les utiliser comme technique de référence
pour l’évaluation des algorithmes de visibilité conservatifs ou agressifs [120]. Ce travail a été effectué
récemment par Bittner et al. dans le cas particulier de la 2D12 [19]. Un travail futur très intéressant
consisterait de l’étendre au cas général 3D.
Les méthodes exactes de calcul de visibilité fournissent la liste de tous les objets visibles depuis
la cellule, sans tenir compte de leur <degré> de visibilité. Les objets qui ne sont que très peu visibles,
par exemple au travers d’une toute petite ouverture, seront affichés au même titre que les objets situés
à l’avant-plan, même s’ils ne contribuent presque pas aux images générées. Si l’on veut éviter l’affi-
chage de ces objets, qui ne couvrent qu’une surface négligeable, il est nécessaire d’éliminer tous les
défauts de modélisation (interstices à la jointure des maillages, etc.) avant le précalcul de visibilité.
Cette étape est très contraignante et n’est pas toujours réalisable. Une solution consisterait à évaluer
le degré de visibilité de chaque objet, et à rejeter les objets dont la visibilité est inférieure à un certain
seuil. Cette mesure pourrait être effectuée dans l’espace de Plücker : étant donné que chaque polytope
correspond à un ensemble de droites non bloquées, il faudrait mesurer la <taille> des ensembles de
droites représentés par chacun des polytopes afin d’éliminer ceux qui sont jugés négligeables. On ob-
tiendrait de la sorte un algorithme de visibilité agressif, mais dont l’erreur serait bornée, ce qui n’existe
146 chapitre 7. Conclusions et perspectives
pas encore à l’heure actuelle dans le domaine de l’<occlusion culling>. Notons cependant que des cal-
culs de visibilité avec une erreur bornée ont déjà été proposés dans le domaine du calcul d’éclairage
par Soler et al. [142,144,143]. Du point de vue du temps de calcul, les algorithmes exacts sont coûteux
car intrinsèquement complexes. Cependant, il n’est pas toujours nécessaire de les utiliser, et dans bien
des cas, des méthodes conservatives ou agressives permettent d’obtenir des résultats similaires en des
temps beaucoup plus réduits. Pour une meilleure efficacité, ces méthodes devraient être utilisées à la
place des algorithmes exacts, et l’on devrait réserver ces derniers aux cas difficiles [19]. Une piste de
recherche prometteuse serait donc de mettre au point un <framework> complet, tel que celui proposé
par Aila et al. pour l’<occlusion culling> en ligne [2], permettant de combiner différentes techniques
pour précalculer la visibilité dans les scènes complexes. Les méthodes conservatives seraient utilisées
en premier lieu, pour filtrer la base de données, et donner une première estimation de l’ensemble
des objets visibles. Un algorithme exact pourrait ensuite être utilisé pour éliminer complètement la
sur-conservativité due à la méthode. Finalement, une technique agressive avec contrôle de l’erreur
permettrait d’éliminer du PVS les objets très peu visibles. C’est seulement la combinaison de ces
différentes méthodes qui pourrait fournir un algorithme strictement <output sensitive>, c’est-à-dire
dont la complexité est proportionnelle au nombre d’objets visibles, et fournissant le PVS le plus per-
formant. Idéalement, un tel <framework> devrait également permettre de régler le compromis entre
qualité et temps de calcul, en proposant rapidement une solution grossière, puis en offrant la possibi-
lité d’améliorer cette solution en augmentant le temps de calcul.
Dans le chapitre 4, nous nous sommes intéressé au problème de la discrétisation de l’espace navi-
gable. Nous avons proposé d’abandonner l’idée de découper l’espace navigable en cellules et de calcu-
ler un PVS pour chacune d’entre elles. A la place, nous avons proposé de stocker l’ombre générée par
chacun des objets lorsqu’il est remplacé par une source lumineuse. Nous avons vu que l’amélioration
du temps d’affichage passait impérativement par la mise au point d’un algorithme <output sensitive>.
L’implémentation que nous avons proposée ne possède malheureusement pas cette caractéristique,
mais elle reste néanmoins intéressante, car elle permet d’encoder la visibilité de manière avantageuse
dans les grands espaces navigables. Si de meilleurs écrans virtuels étaient mis au point et utilisés,
elle pourrait même devenir une alternative compétitive par rapport au PVS, même dans le cas d’un
espace navigable réduit. Tout au long de notre travail, nous avons été confronté au paradoxe suivant :
les algorithmes de calcul de visibilité sont très dépendants des scènes, mais il n’existe pourtant pas
de scènes de référence (ni à fortiori de classification de ces scènes). De ce fait, les méthodes de visi-
bilité sont rarement évaluées de manière systématique, et il n’existe quasiment aucune comparaison
de leur efficacité respective. Le praticien n’a que peu de points de comparaison, et doit se fier à ses
seules intuition et expérience lorsqu’il choisit d’utiliser un algorithme plutôt qu’un autre. Nous avons
déjà mentionné l’utilisation des méthodes exactes de visibilité comme méthodes de référence pour
comparer les algorithmes entre eux. Mais une telle comparaison ne pourra être réalisée de manière
intéressante que si des scènes de référence voient le jour, et si l’on en connaı̂t les propriétés. Pour
étudier ces dernières, Feixas et al. ont proposé d’évaluer la complexité de la scène au sens de la théorie
de l’information [61]. Dans un but similaire, nous pensons que l’on pourrait se servir de l’encodage de
la visibilité par capsules comme descripteurs de visibilité, en étudiant la distribution de leurs secteurs
et de leurs distances frontières. Par exemple, des scènes denses auront des distances frontières petites
et similaires. Au contraire, des scènes <désordonnées> donneront beaucoup de petits secteurs avec
des discontinuités fortes entre les frontières. Ce genre de description de scènes semble plus naturel
que la description de la visibilité encodée sous forme de PVS, et pourrait être utilisée pour créer des
ensembles de tests, à l’instar de ceux existants dans d’autres domaines d’informatique appliquée.
147
Finalement, nous nous sommes intéressé dans le chapitre 6 au cas particulier des scènes d’intérieur,
et avons décrit un algorithme permettant de générer des graphes cellules-portails de manière auto-
matique. A nos yeux, notre principale contribution a été de montrer que ce problème pouvait être
formulé en termes de segmentation d’images. Nous avons également expliqué comment utiliser un
algorithme de <watershed> pour obtenir une décomposition proche de la décomposition <classique>,
traditionnellement créée à la main. Cette nouvelle formulation offre de nombreuses perspectives : uti-
lisation d’autres algorithmes de segmentation, utilisation de techniques plus avancées pour améliorer
les résultats du <watershed> et éliminer la sur-segmentation, etc.
Les possibilités d’utilisation de cette technique de génération automatique sont nombreuses car
les scènes d’intérieur sont très répandues et car les graphes cellules-portails sont utilisés de manière
quasiment universelle dans tous les <moteurs de rendu>, en raison de leur faible coût mémoire et
de leur grande efficacité. Lorsque la scène doit être modélisée, l’utilité d’une méthode de génération
automatique peut paraı̂tre discutable, car le temps nécessaire pour placer les cellules et les portails de
manière manuelle est faible comparativement au temps de modélisation. Cependant, une technique
automatique reste intéressante, ne fût-ce que pour donner une première information de positionne-
ment des portails. Dans de nombreuses autres situations, l’utilisation d’un algorithme de génération
entièrement automatique est obligatoire, chaque fois que les utilisateurs des logiciels de navigation
interactive, tels que les médecins ou les architectes, sont étrangers aux problématiques de l’affichage.
Il en est de même lorsque l’on souhaite visualiser des scènes déjà modélisées, à l’aide de logiciels de
CAD par exemple dans le domaine industriel, ou encore si l’on désire visualiser des scènes acquises
de manière automatique, à l’aide de scanners 3D.
Nous aimerions conclure ce document par les perspectives de modification incrémentale de l’in-
formation de visibilité. Dans le domaine de l’<occlusion culling>, l’ensemble des travaux consacrés
au précalcul supposent que la scène est complètement statique, et qu’aucune primitive ne peut être
déplacée durant la phase de visualisation. Lorsqu’un changement survient, l’ensemble de la solution
doit être recalculé à partir de zéro. Pourtant, seul un sous-ensemble de cette information a effective-
ment été modifié. Il serait donc intéressant de l’identifier et de l’isoler, pour limiter les calculs à ces
seuls changements. Ce type d’approche incrémentale a été utilisé avec succès dans certains domaines
de la synthèse d’images proches de la visibilité, tels que le calcul d’illumination globale à l’aide de
méthodes de radiosité [32, 51]. En étendant ces algorithmes à l’<occlusion culling>, on supprime-
rait la principale limitation des algorithmes de précalcul, en permettant à l’utilisateur de modifier la
géométrie de la scène pendant la navigation interactive.
Index
A champ de hauteurs, 127, 129

Adaptively Sampled Distance Fields, 127 squelette d’un champ de distances, 62
ADF, voir Adaptively Sampled Distance Fields changement topologique, 35, 36
algorithme classe isotopique, voir droite, 87
algorithme de balayage, 62 classification de rayons, 53
algorithme de remplissage, 131 combinaison linéaire convexe, 21
algorithme prudent, 12 complexe
parcours de graphe en profondeur, 60 complexe cellulaire, 22
analogie complexe de polyèdres, 22
circuit électrique, 100 complexe de visibilité, 43
innondation, 127 compression avec perte, 107
source lumineuse, 37 compression sans perte, 107
arête génératrice, 39 conservative, voir algorithme prudent
arbre d’occultation, 70 Constructive Solid Geometry, 61, 66, 67, 69,
arrêt précoce, 66 90
arrangement coordonnées
arrangement d’hyperplans, voir polyèdre de Grassmann, 27
arrangement dual, 42 de Plücker dans R2 , 28
arrangement d’hyperplans, 22 de Plücker dans R3 , 30
aspect d’une scène, 35 CPG, voir Cell-and-Portal Graph
critical swath, voir surface critique
B CSG, voir Constructive Solid Geometry
barrière virtuelle, 52
Binary Space Partitionning, 61, 62, 70, 71, 101, D
126, 135, 141 description combinatoire, 21
BSP, voir Binary Space Partitionning droite
classe isotopique, 79
C droite poignardante, 26
calcul d’enveloppe convexe, 21 droite poignardante extrême, 37
catalogue d’adjacence, 44 droite représentative, 78
Cell-and-Portal Graph, 34, 60–63, 124, 125, 129, dual
131, 136–144 espace dual, voir espace
cellule graphe dual, 23
cellule d’un complexe, 22 dualité
cellule d’un graphe cellules-portails, 61 algèbre linéaire, 24
cellule d’un PVS, 46 géométrie algorithmique, 24
cellule de visibilité constante, 98 programmation linéaire, 24
champ
INDEX 149
E I
echantillonnage, 53 imposteur, 11, 53
ecran interactif, 10
écran virtuel, 52 item buffer, 54, voir visibilité
érosion des écrans, 51
définition, 37 L
fusion des écrans, voir fusion des pénombres l’<Asp>, 41
réduction des écrans, 51 lancer de rayons, 26
elimination des surfaces cachées, voir hidden lignes de partage des eaux, 124
surface removal O
enveloppe convexe, voir polyèdre objet lisse, 38
espace occluder, voir écran
espace de Plücker, 30 opérateurs de projection étendus, 50
espace des droites, 54 output sensitive, 12
espace dual, 24 over-segmentation, voir sur-segmentation
espace navigable, 35
espace primal, 24 P
espace projectif, 27, 28 pénombre, 37
evénement de visibilité, 36 partition
extremal stabbing line, voir droite poignardante en cellules d’aspect constant, voir parti-
extrême tion VSP
en cellules de visibilité constante, 56
F partition VSP, voir View Space Partition
face d’un graphe, 23 Plücker
face d’un polyèdre, 21 coordonnées de Plücker, voir coordonnées
fusion des pénombres, 47 espace de Plücker, voir espace
quadrique de Plücker, voir quadrique de
G
Plücker
Geodesic Skeleton Zones of Influence, 128, 132
poignardant, voir droite
Global Occlusion Map, 52
polyèdre
GOM, voir Global Occlusion Map
1-squelette d’un polyèdre, voir squelette
graphe
algorithme d’énumération de sommets, 21
arc d’un graphe, 23
arête d’un polyèdre, 21
face d’un graphe, 23
facette d’un polyèdre, 21
graphe cellules-portails, voir Cell-and-Portal
H-Représentation, 21
Graph
k-squelette d’un polyèdre, voir squelette
graphe d’aspect, 35, 45, 56
polyèdre borné, voir polytope
graphe d’aspect lineaire, 58
polyèdre non convexe, 22
graphe d’incidence d’un polyèdre, 22
sommet d’un polyèdre, 21
graphe dual, 23
V-Représentation, 21
nœud d’un graphe, 23
polytope, 20
H portail, 60
hidden surface removal, 34 position générique, 39
hoops, 49, 52 Potentially Visible Set, voir PVS
HSR, voir hidden surface removal PVS
hypercube, 52 écrans virtuels, 58
agressif, 48
150 INDEX
approximatif, 48 sur-conservativité
calcul incrémental, 57 due à la méthode, 47
cellule d’un PVS, voir cellule due à la partition, 46
compression, 58, 99 sur-segmentation, 137
conservatif, 48, 51 surface critique, 36
dynamique, 58 surface réglée, 87
exact, 48, 66, 98
fusion des cellules, 57 T
partition, 56, 57 tampon de profondeur, voir z-buffer
pré-calcul, 98 triangulation de Delaunay, 23
principe, 12, 46, 65, 98
V
stockage, 58
View Space Partition, 35, 36, 41, 56
Q visibilité
quadrique de Plücker, 32 agressive, 48
quadrique réglée, 37 avec précalcul, 13
calcul approximatif, 48
R calcul conservatif, 48
radiosité, 43, 88, 147 depuis un point, 46, 47
ray tracing, voir lancer de rayons depuis une région, 46
requête d’occultation, 66, 70, 78, 82, 89, 94 en ligne, 13
exacte, 48
S
globale, 42
scène
item buffer, 105, 107, 109
2D 12 , 52, 54, 62, 63, 88, 95
robuste, 44
3D + ε, 54
z-buffer, 53, 54
architecturale, 58
visibility event, voir événement de visibilité
complexe, 10
voxel, 49
d’extérieur, 114
voxelisation, 49
d’intérieur, 114
VSP, voir View Space Partition
de ville, 58
vues qualitativement équivalentes, 35
mixte, 108
segment critique, 55 W
segment libre maximal, 43 watershed, voir lignes de partages des eaux
ShieldTester, 49
silhouette Z
silhouette étendue, 66, 78, 80 z-buffer, voir visibilité
silhouette ponctuelle, 79
SKIZ, voir Geodesic Skeleton Zones of Influence
sommet apparent, 36
squelette
1-squelette d’un polyèdre, 22
champ de distances, 62
k-squelette d’un polyèdre, 22
squelette de visibilité, 44
squelette de visibilité robuste, 44
structure combinatoire, 45
stabbing line, voir droite poignardante
Bibliographie
[1] S. Adrian, M. Hampton, S. Nirenstein, J. Gain, and E. Blake, “Accelerating ray shooting
through aggressive 5d visibility pre-processing,” in Proc. of Afrigraph, 2003, pp. 95–100. (cité
pages 52 et 53)
[2] T. Aila and V. Miettinen, “dpvs : An occlusion culling system for massive dynamic environ-
ments,” IEEE Computer Graphics & Applications, pp. 86–97, 2004. (cité pages 14, 91 et 146)
[3] J. M. Airey, J. H. Rohlf, and F. P. Brooks, Jr., “Towards image realism with interactive up-
date rates in complex virtual building environments,” in Proc. of the Symp. on Interactive 3D
graphics, March 1990, pp. 41–50. (cité pages 14, 53, 60, 61 et 62)
[4] D. Aliaga, J. Cohen, A. Wilson, E. Baker, H. Zhang, C. Erikson, K. Hoff, T. Hudson, W. Stuerz-
linger, R. Bastos, M. Whitton, F. Brooks, and D. Manocha, “Mmr : an interactive massive mo-
del rendering system using geometric and image-based acceleration,” in Proc. of the Symp. on
Interactive 3D graphics, 1999, pp. 199–206. (cité à la page 11)
[5] D. G. Aliaga and A. Lastra, “Automatic image placement to provide a guaranteed frame rate,”
in Proc. of the Symp. on Interactive 3D graphics, 1999, pp. 307–316. (cité à la page 11)
[6] C. Andújar, C. Saona-Vazquez, and I. Navazo, “Lod visibility culling and occluder synthesis,”
Computer Aided Design, vol. 32, no. 3, pp. 773–783, 2000. (cité pages 49, 50 et 52)
[7] C. Andújar, P. Vázquez, and M. Fairén, “Way-finder : Guided tours through complex walk-
through models,” Computer Graphics Forum, vol. 23, no. 3, pp. 499–508, 2004. (cité à la
page 126)
[8] J. Arvo and D. Kirk, “Fast ray tracing by ray classification,” in Proc. of the Symp. on Interactive
3D graphics, 1987, pp. 55–64. (cité pages 52 et 53)
[9] U. Assarsson and T. Möller, “Optimized view frustum culling algorithm for bounding boxes,”
Journal of Graphics Tools, vol. 5, no. 1, pp. 9–22, 2000. (cité à la page 143)
[10] D. Avis and K. Fukuda, “Reverse search for enumeration.” Discrete Applied Mathematics,
vol. 65, no. 1-3, pp. 21–46, 1996. (cité à la page 69)
[11] C. L. Bajaj and V. Pascucci, “Splitting a complex of convex polytopes in any dimension,” in
Proc. of SoCG, 1996, pp. 88–97. (cité pages 70 et 71)
[12] D. Bartz, M. Meissner, and T. Hüttner, “Opengl-assisted occlusion culling for large polygonal
models,” Computer & Graphics, vol. 23, pp. 667–679, 1997. (cité à la page 15)
[13] F. Bernardini and J. T. Klosowski, “Directional discretized occluders for accelerated occlusion
culling,” Computer Graphics Forum, 2000. (cité à la page 58)
[14] S. Beucher, “The watershed transformation applied to image segmentation,” in Conference on
Signal and Image Processing in Microscopy and Microanalysis, September 1991, pp. 299–314.
(cité à la page 128)
152 BIBLIOGRAPHIE
[15] P. Bhattacharya, “Efficient neighbor finding algorithms in quadtree and octree,” Master’s thesis,
Indian Institute of Technology, Kanpur, 2001. (cité à la page 137)
[16] L. Bishop, D. Eberly, T. Whitted, M. Finch, and M. Shantz, “Designing a pc game engine,”
IEEE Computer Graphics & Applications, pp. 46–53, 1998. (cité à la page 63)
[17] J. Bittner, M. W. H. Piringer, and W. Purgathofer, “Coherent hierarchical culling : Hardware oc-
clusion queries made useful,” in Proc. of Eurographics, vol. 13, no. 3, 2004. (cité à la page 14)
[18] J. Bittner and P. Wonka, “Visibility in computer graphics,” Environment and Planning B : Plan-
ning and Design, vol. 30, no. 5, pp. 729–756, sep 2003. (cité pages 11, 34 et 59)
[19] J. Bittner, P. Wonka, and M. Wimmer, “Fast exact from-region visibility in urban scenes,” in
Proc. of the Eurographics Symposium on Rendering, 2005, pp. 223–230. (cité pages 54, 63,
66, 68, 95, 145 et 146)
[20] J. Bittner, “Hierarchical techniques for visibility computations,” Ph.D. dissertation, Czech
Technical University in Prague, 2002. (cité pages 19, 27, 42, 43, 48, 54, 59, 66, 69, 70,
84, 90, 101 et 102)
[21] J. Bittner and V. Havran, “Exploiting temporal and spatial coherence in hierarchical visibility
algorithms,” in Proc. of SCCG, 2001. (cité pages 14 et 106)
[22] J. Bittner, V. Havran, and P. Slavik, “Hierarchical visibility culling with occlusion trees,” in
Proc. of Computer Graphics International, 1998. (cité à la page 70)
[23] J. Bittner and J. Přikryl, “Exact regional visibility using line space partitioning,” Institute of
Computer Graphics and Algorithms, Vienna University of Technology, Tech. Rep. TR-186-2-
01-06, march 2001. (cité pages 3, 25, 26 et 28)
[24] J. Bittner, P. Wonka, and M. Wimmer, “Visibility preprocessing for urban scenes using line
space subdivision,” in Proc. of Pacific Graphics, 2001. (cité pages 54, 66, 68 et 70)
[25] M. Blais and P. Poulin, “Sampling visibility in three-space,” in Proc.Western Computer Gra-
phics Symposium, April 1998. (cité à la page 53)
[26] P. Brunet, I. Navazo, C. Saona-Vázquez, and J. Rossignac, “Hoops : 3d curves as conservative
occluders for cell-visibility,” Computer Graphics Forum, 2001. (cité pages 49, 52, 58, 118
et 119)
[27] E. E. Catmull, “A subdivision algorithm for computer display of curved surfaces.” Ph.D. dis-
sertation, University of Utah, 1974. (cité à la page 11)
[28] B. Chen and M. X. Nguyen, “Pop : a hybrid point and polygon rendering system for large data,”
in Proc. of the conference on Visualization, 2001, pp. 45–52. (cité à la page 11)
[29] J. Chhugani, B. Purnomo, S. Krishnan, J. Cohen, S. Venkatasubramanian, and D. Johnson,
“vlod : High-fidelity walkthrough of large virtual environments,” IEEE Transactions on Visua-
lization & Computer Graphics, vol. 11, no. 1, pp. 35–47, 2005. (cité pages 11, 52 et 58)
[30] F. S. Cho and D. A. Forsyth, “Interactive ray tracing with the visibility complex.” Computer &
Graphics, vol. 23, no. 5, pp. 703–717, 1999. (cité à la page 43)
[31] Y. Chrysanthou, D. Cohen-Or, and D. Lischinski, “Fast approximate quantitative visibility for
complex scenes,” in Proc. of Computer Graphics International, 1998, p. 220. (cité à la page 44)
[32] Y. Chrysanthou and M. Slater, “Incremental updates to scenes illuminated by area light
sources,” in Proc. of Eurographics Rendering Workshop, 1997, pp. 103–114. (cité à la
page 147)
BIBLIOGRAPHIE 153
[33] J. H. Clark, “Hierarchical geometric models for visible surface algorithms,” Commun. ACM,
vol. 19, no. 10, pp. 547–554, 1976. (cité à la page 13)
[34] J. D. Cohen, D. G. Aliaga, and W. Zhang, “Hybrid simplification : combining multi-resolution
polygon and point rendering,” in Proc. of the conference on Visualization, 2001, pp. 37–44.
(cité à la page 11)
[35] D. Cohen-Or, Y. Chrysanthou, C. T. Silva, and F. Durand, “A survey of visibility for walk-
through applications,” IEEE Transactions on Visualization & Computer Graphics, 2002. (cité
pages 11, 13, 34 et 59)
[36] D. Cohen-Or, E. Sayer, A. Lerner, Y. Chrysanthou, and O. Deussen, “Aggressive visibility for
rendering extremely complex foliage scenes,” in Israel-Kora Conference on Geometric Mode-
ling and Computer Graphics, 2004. (cité à la page 53)
[37] D. Cohen-Or, A. Solomovic, and D. Levin, “Three-dimensional distance field metamorphosis,”
ACM Transactions on Graphics, vol. 17, no. 2, pp. 116–141, 1998. (cité à la page 126)
[38] D. Cohen-Or, C. Yorgios, C. Silva, and F. Durand, “A survey of visibility for walkthrough appli-
cations,” IEEE Transactions on Visualization & Computer Graphics, 2002. (cité à la page 59)
[39] D. Cohen-Or and E. Zadicario, “Visibility streaming for network-based walkthroughs,” in Proc.
of Graphics Interface, June 1998, pp. 1–7. (cité à la page 15)
[40] S. Coorg and S. Teller, “Temporally coherent conservative visibility,” in Proc. of SoCG, 1996.
(cité pages 41, 58 et 106)
[41] T. Cormen, C. Leiserson, and R. Rivest, Introduction à l’algorithmique. Dunod, 2002. (cité
pages 24, 60 et 95)
[42] W. T. Corrêa, J. T. Klosowski, and C. T. Silva, “Visibility-based prefetching for interactive out-
of-core rendering,” in Proc. IEEE Symposium on Parallel and Large-Data Visualization and
Graphics, 2003, pp. 1–8. (cité à la page 11)
[43] B. J. Daniel and Y. Mariette, Géométrie algorithmique. Ediscience International, 1995. (cité
pages 19 et 31)
[44] C.-O. Daniel, F. Gadi, H. Dan, and Z. Eyal, “Conservative visibility and strong occlusion for
viewspace partitioning of densely occluded scenes,” in Proc. of Eurographics, vol. 17, no. 3,
1998, pp. 244–254. (cité pages 48, 49 et 57)
[45] M. de Berg, M. van Kreveld, M. Overmars, and O. Schwartzkop, Computational Geometry :
Algorithms and Applications. Springer, 1999. (cité pages 23 et 24)
[46] P. Decaudin and F. Neyret, “Rendering forest scenes in real-time,” in Proc. of the Eurographics
Symposium on Rendering, june 2004, pp. 93–102. (cité à la page 11)
[47] X. Décoret, “Pré-traitement de grosses bases de données pour la visualisation interactive,”
Ph.D. dissertation, Université Joseph Fourrier, octobre 2002. (cité pages 37, 50, 51, 52, 59
et 60)
[48] X. Décoret, G. Debunne, and F. Sillion, “Erosion based visibility preprocessing,” in Proc. of
Eurographics Rendering Workshop, 2003. (cité à la page 51)
[49] O. Devillers, V. Dujmovic, H. Everett, X. Goaoc, S. Lazard, H.-S. Na, and S. Petitjean, “The
expected number of 3d visibility events is linear,” SIAM J. Comput., vol. 32, no. 6, pp. 1586–
1620, 2003. (cité à la page 41)
154 BIBLIOGRAPHIE
[50] L. Downs, T. Akenine-Möller, and C. Séquin, “Occlusion horizons for driving through urban
scenery,” in Proc. of the Symp. on Interactive 3D graphics, 2001, pp. 121–124. (cité pages 52
et 58)
[51] G. Drettakis and F. Sillion, “Interactive update of global illumination using a line-space hierar-
chy,” in Proc. of Siggraph, Aug 1997. (cité à la page 147)
[52] F. Duguet and G. Drettakis, “Robust epsilon visibility,” in Proc. of Siggraph, July 2002. (cité
pages 40, 44 et 45)
[53] F. Durand, G. Drettakis, and C. Puech, “The 3d visibility complex,” ACM Transactions on
Graphics, vol. 21, no. 2, April 2002. (cité à la page 43)
[54] F. Durand, “3d visibility : Analytical study and applications,” Ph.D. dissertation, Université
Joseph Fourier, Grenoble I, July 1999. (cité pages 11, 24, 33, 37, 38, 40, 42, 43, 44, 54, 60
et 84)
[55] F. Durand, G. Drettakis, and C. Puech, “The 3d visibility complex, a new approach to the
problems of accurate visibility,” in Proc. of Eurographics Rendering Workshop, Jun 1996, pp.
245–257. (cité pages 43, 45 et 94)
[56] F. Durand, G. Drettakis, and C. Puech, “The visibility skeleton : a powerful and efficient multi-
purpose global visibility tool,” in Proc. of Siggraph, 1997, pp. 89–100. (cité pages 44, 45
et 94)
[57] F. Durand, G. Drettakis, J. Thollot, and C. Puech, “Conservative visibility preprocessing using
extended projections,” in Proc. of Siggraph, 2000. (cité pages 50, 57 et 58)
[58] D. W. Eggert, K. W. Bowyer, C. R. Dyer, H. I. Christensen, and D. B. Goldgof, “The scale
space aspect graph,” IEEE Trans. Pattern Anal. Mach. Intell., vol. 15, no. 11, pp. 1114–1130,
1993. (cité à la page 35)
[59] M. Feixas, E. Acebo, P. Bekaert, and M. Sbert, “Information theory tools for scene discretiza-
tion,” in Proc. of Eurographics Rendering Workshop, 1999, pp. 103–114. (cité à la page 59)
[60] M. Feixas, E. Acebo, and M. Sbert, “Entropy of scene visibility,” in Proc. of WSCG, 1999, pp.
45–52. (cité à la page 59)
[61] M. Feixas, E. del Acebo, P. Bekaert, and M. Sber, “An information theory framework for the
analysis of scene complexity,” in Proc. of Eurographics, vol. 18(3), 1999, pp. 95–106. (cité
pages 59 et 146)
[62] P. Felkel, M. Bruckschwaiger, and R. Wegenkittl, “Implementation and complexity of the
watershed-from-markers algorithm computed as a minimal cost forest,” Computer Graphics
Forum, vol. 20, no. 3, 2001. (cité pages 126 et 144)
[63] J. D. Foley, A. van Dam, S. K. Feiner, and J. F. Hughes, Computer graphics : principles and
practice (2nd ed.). Addison-Wesley Longman Publishing Co., Inc., 1990. (cité pages 11
et 34)
[64] S. F. Frisken, R. N. Perry, A. P. Rockwood, and T. R. Jones, “Adaptively sampled distance
fields : A general representation of shape for computer graphics,” in Proc. of Siggraph, 2000,
pp. 249–254. (cité pages 126, 127, 136 et 137)
[65] K. Fukuda and V. Rosta, “Combinatorial face enumeration in convex polytopes.” Computatio-
nal Geometry, vol. 4, pp. 191–198, 1994. (cité à la page 70)
[66] K. Fukuda, “cdd package,”
http ://www.ifor.math.ethz.ch/˜fukuda/cdd home/cdd.html. (cité à la page 90)
BIBLIOGRAPHIE 155
[67] T. A. Funkhouser, “Ring : A client-server system for multi-user virtual environments,” in Proc.
of the Symp. on Interactive 3D graphics, 1995, pp. 85–92, 209. (cité à la page 11)
[68] T. A. Funkhouser, “Database management for interactive display of large architectural models,”
in Proc. of Graphics Interface, 1996, pp. 1–8. (cité à la page 11)
[69] Z. Gigus and J. Malik, “Computing the aspect graph for line drawings of polyhedral objects,”
IEEE Trans. Pattern Anal. Mach. Intell., vol. 12, no. 2, pp. 113–122, 1990. (cité pages 37
et 41)
[70] X. Goaoc, “Structures de visibilité globales : taille, calcul et dégénérescences,” Ph.D. disserta-
tion, Université Nancy 2, Mai 2004. (cité pages 19, 38, 40, 42, 43 et 45)
[71] E. Gobbetti and F. Marton, “Far Voxels – a multiresolution framework for interactive rende-
ring of huge complex 3d models on commodity graphics platforms,” ACM Transactions on
Graphics, vol. 24, no. 3, August 2005. (cité pages 10, 11 et 53)
[72] R. C. Gonzales and P. Wintz, Digital image processing (2nd ed.). Boston, MA, USA : Addison-
Wesley Longman Publishing Co., Inc., 1987. (cité pages 62 et 126)
[73] C. Gotsman, O. Sudarsky, and J. A. Fayman, “Optimized occlusion culling using five-
dimensional subdivision,” Computer & Graphics, vol. 23, no. 5, pp. 645–654, 1999. (cité
pages 52, 53 et 58)
[74] N. Greene, M. Kass, and G. Miller, “Hierarchical z-buffer visibility,” in Proc. of Siggraph,
[75] E. F. Grove, T. M. Murali, and J. S. Vitter, “The object complexity model for hidden-surface
removal,” International Journal of Computational Geometry and Applications, vol. 9, no. 2,
pp. 207–217, 1999. (cité à la page 59)
[76] L. J. Guibas, R. Motwani, and P. Raghavan, “The robot localization problem,” SIAM J. Comput.,
vol. 26, no. 4, pp. 1120–1138, 1997. (cité à la page 55)
[77] E. Haines and J. R. Wallace, “Shaft culling for efficient ray-cast radiosity,” in Proc. of Euro-
graphics Rendering Workshop, 1991. (cité à la page 89)
[78] S. Hanan, Applications of Spatial Data Structures : Computer Graphics, Image Processing,
and GIS. Addison-Wesley, 1990. (cité à la page 137)
[79] P. Harry, “Conservative visibility preprocessing for efficient walkthrouh of 3d scenes,” in Proc.
of Graphics Interface, 1993, pp. 166–173. (cité à la page 41)
[80] D. Haumont, “Les imposteurs tridimensionnels,” Master’s thesis, Université Libre de Bruxelles,
[81] D. Haumont, O. Debeir, and F. Sillion, “Volumetric cell-and-portal generation,” in Proc. of
Eurographics, vol. 22, no. 3, September 2003, pp. 303–312. (cité pages 124 et 138)
[82] D. Haumont, O. Mäkinen, and S. Nirenstein, “A low dimensional framework for exact polygon-
to-polygon occlusion queries,” in Proc. of the Eurographics Symposium on Rendering, 2005,
pp. 211–222. (cité à la page 67)
[83] W. P. Heinrich Hey, “Occlusion culling methods,” in Eurographics State of the Art Reports,
2001, pp. 21–42. (cité pages 11 et 34)
[84] E. Hidalgo and R. J. Hubbold, “Hybrid geometric - image based rendering.” Computer Gra-
phics Forum, vol. 21, no. 3, 2002. (cité à la page 11)
156 BIBLIOGRAPHIE
[85] L. Hong, S. Muraki, A. Kaufman, D. Bartz, and T. He, “Virtual voyage : Interactive navigation
in the human colon,” in Proc. of Siggraph, Augustus 1997, pp. 27–34. (cité pages 62, 125
et 133)
[86] W. Hua, H. Bao, Q. Peng, and A. R. Forrest, “The global occlusion map : a new occlusion
culling approach,” in Proc. of VRST, 2002, pp. 155–162. (cité pages 52, 58, 100, 102 et 118)
[87] W. F. H. Jiménez, C. Esperança, and A. A. F. Oliveira, “Efficient algorithm for computing
conservative portal visibility information,” in Proc. of Eurographics, vol. 19, no. 3, 2000. (cité
pages 60 et 63)
[88] C. B. Jones, “A new approach to the ‘hidden line’ problem,” Computer Journal, vol. 14, no. 3,
pp. 232–237, August 1971. (cité pages 13, 60, 61 et 62)
[89] D. Jung and K. Gupta, “Octree-based hierarchical distance maps for collision detection,”
in IEEE International Conference on Robotics and Automation, 1996, pp. 454–459. (cité
pages 126 et 127)
[90] J. Klein, J. Krokowski, M. Fischer, M. Wand, R. Wanka, and F. M. auf der Heide, “The ran-
domized sample tree : a data structure for interactive walkthroughs in externally stored virtual
environments,” in Proc. of VRST, 2002, pp. 137–146. (cité à la page 11)
[91] J. T. Klosowski and C. T. Silva, “The prioritized-layered projection algorithm for visible set
estimation,” IEEE Transactions on Visualization & Computer Graphics, vol. 6, no. 2, pp. 108–
123, /2000. (cité à la page 83)
[92] J. J. Koenderink and A. J. van Doorn, “The singularilarities of the visual mapping,” Biol. Cyber.,
vol. 24, pp. 51–59, 1976. (cité à la page 41)
[93] J. J. Koenderink and A. J. van Doorn, “The internal representation of solid shape with respect
to vision,” Biol. Cyber., vol. 32, pp. 211–216, 1979. (cité à la page 41)
[94] V. Koltun, Y. Chrysanthou, and D. Cohen-Or, “Virtual occluders : An efficient intermediate
PVS representation,” in Proc. of Eurographics Rendering Workshop, 2000. (cité pages 52, 58
et 102)
[95] V. Koltun, D. Cohen-or, and Y. Chrysanthou, “Hardware-accelerated from-region visibility
using a dual ray space,” in Proc. of Eurographics Rendering Workshop, 2001. (cité pages 54,
66, 68 et 70)
[96] S. Laine, “A general algorithm for output-sensitive visibility preprocessing,” in Proc. of the
Symp. on Interactive 3D graphics, 2005, pp. 31–39. (cité pages 57, 89, 95 et 119)
[97] S. Laine, T. Aila, U. Assarson, J. Lehtinen, and T. Akenine-Möller, “Soft shadow volumes for
ray tracing,” in Proc. of Siggraph, vol. 24, 2005. (cité à la page 81)
[98] L. Leblanc and P. Poulin, “Guaranteed occlusion and visibility in cluster hierarchical radiosity,”
in Proc. of Eurographics Rendering Workshop, June 2000, pp. 89–100. (cité à la page 49)
[99] S. Lefebvre and S. Hornus, “Automatic cell-and-portal decomposition,” INRIA, Tech. Rep.
4898, July 2003. (cité pages 61 et 144)
[100] Y.-W. Lei and M. Ouhyoung, “Carving : a novel method of visibility preprocessing for unres-
tricted three-dimensional environments.” The Visual Computer, vol. 13, no. 6, pp. 283–294,
1997. (cité pages 60 et 61)
[101] A. Lerner, Y. Chrysanthou, and D. Cohen-Or, “Breaking the walls : Scene partitioning and
portal creation,” in Proc. of Pacific Graphics, 2003. (cité pages 62, 140 et 144)
BIBLIOGRAPHIE 157
[102] T. Leyvand, O. Sorkine, and D. Cohen-Or, “Ray space factorization for from-region visibility,”
in Proc. of Siggraph, 2003. (cité pages 54 et 103)
[103] H. L. Lim, “Toward a fuzzy hidden surface algorithm,” in Proc. of Computer Graphics Inter-
national, 1992. (cité à la page 51)
[104] S. Lipschutz and M. Lipson, Algèbre linéaire. EdiScience (série Schaum), 2001. (cité à la
page 24)
[105] B. Lloyd and P. K. Egbert, “Horizon occlusion culling for real-time rendering of hierarchical
terrains.” in Proc. of the conference on Visualization, 2002. (cité pages 52 et 58)
[106] N. Low and A. Datta, “A new technique for rendering complex portals,” IEEE Transactions on
Visualization & Computer Graphics, vol. 11, no. 1, pp. 81–90, 2005. (cité pages 60, 62 et 63)
[107] D. Luebke and G. Chris, “Portals and mirrors : Simple, fast evaluation of potentially visible
sets,” in Proc. of the Symp. on Interactive 3D graphics, 1995. (cité pages 58, 60, 61, 62 et 63)
[108] P. W. C. Maciel and P. Shirley, “Visual navigation of large environments using textured clus-
ters,” in Proc. of the Symp. on Interactive 3D graphics, 1995, pp. 95–102, 211. (cité à la
page 11)
[109] A. P. Mangan and R. T. Whitaker, “Partitioning 3d surface meshes using watershed segmenta-
tion,” IEEE Transactions on Visualization & Computer Graphics, vol. 5, no. 4, pp. 308–321,
1999. (cité à la page 126)
[110] D. J. Meagher, “Efficient synthetic image generation of arbitrary 3-d objects,” in Proc. IEEE
Conf. on Pattern Recognition and Image Processing, 1982, pp. 473–478. (cité à la page 13)
[111] D. Meneveaux, E. Maisel, F. Coudret, and K. Bouatouch, “Structuration de scènes architectu-
rales complexes en vue de simulation d’éclairage,” IRISA, Tech. Rep. 1034, 1997. (cité à la
page 61)
[112] F. Meyer and S. Beucher, “Morphological segmentation,” Journal of Visual Communication on
Image Representation, vol. 1, no. 1, pp. 21–46, 1990. (cité pages 124, 126 et 137)
[113] F. Mora, L. Aveneau, and M. Mériaux, “Coherent and exact polygon-to-polygon visibility,” in
Proc. of WSCG, 2005. (cité pages 54, 66, 70, 71, 78 et 91)
[114] D. M. Mount and F.-T. Pu, “Binary space partitions in plücker space,” in International Work-
shop on Algorithm Engineering and Experimentation, 1999, pp. 94–113. (cité à la page 71)
[115] B. Nadler, G. Fibich, S. Lev-Yehudi, and D. Cohen-Or, “A qualitative and quantitative visibility
analysis in urban scenes,” Computer & Graphics, vol. 23, no. 5, pp. 655–666, 1999. (cité
pages 47, 49 et 58)
[116] I. Navazo, J. Rossignac, J. Jou, and R. Shariff, “Shieldtester : Cell-to-cell visibility test for
surface occluders,” Computer Graphics Forum, 2003. (cité pages 48, 49 et 83)
[117] L. Niepel, J. Martinka, A. Ferko, and P. Elias, “On scene complexity definition for rendering,”
in Proc. of WSCG, 1995, pp. 209–217. (cité à la page 59)
[118] S. Nirenstein, “Fast and accurate visibility preprocessing,” Ph.D. dissertation, University of
Cape Town, South Africa, 2003. (cité pages 19, 28, 42, 51, 68, 69, 70, 76, 77 et 87)
[119] S. Nirenstein and E. Blake, “Hardware accelerated aggressive visibility preprocessing using
adaptive sampling,” in Proc. of Eurographics Rendering Workshop, 2004. (cité pages 53, 57,
58 et 105)
158 BIBLIOGRAPHIE
[120] S. Nirenstein, E. Blake, and J. Gain, “Exact from-region visibility culling,” in Proc. of Euro-
graphics Rendering Workshop, 2002. (cité pages 27, 42, 43, 44, 48, 54, 59, 66, 69, 70, 71, 78,
79, 83, 89, 90, 91, 92, 93, 95 et 145)
[121] C. O, “Distance transformations : fast algorithms and applications to medical image proces-
sing,” Ph.D. dissertation, Université catholique de Louvain (UCL), Louvain-la-Neuve, Bel-
gium, October 1999. (cité à la page 127)
[122] R. Orti, F. Durand, S. Rivière, and C. Puech, “Using the visibility complex for radiosity com-
putation,” in Applied Computational Geometry, May 1996, pp. 177–190. (cité pages 43 et 45)
[123] R. Pajarola and J. Rossignac, “Compressed progressive meshes,” IEEE Transactions on Visua-
lization & Computer Graphics, vol. 6, no. 1, pp. 79–93, 2000. (cité à la page 11)
[124] I. Pantazopoulos and S. Tzafestas, “Occlusion culling algorithms : A comprehensive survey,”
Journal of Intelligent and Robotic Systems, 2002. (cité pages 11 et 34)
[125] M. Pellegrini, “Ray shooting on triangles in 3-space,” Algorithmica, vol. 9, no. 5, pp. 471–494,
1993. (cité pages 42 et 84)
[126] R. N. Perry and S. F. Frisken, “Kizamu : a system for sculpting digital characters,” in Proc. of
Siggraph, 2001, pp. 47–56. (cité à la page 126)
[127] H. Plantinga, “The asp : A continuous, viewer-centered object representation for computer
vision,” Ph.D. dissertation, University of Wisconsin, 1988. (cité à la page 41)
[128] H. Plantinga and C. R. Dyer, “Visibility, occlusion, and the aspect graph,” Journal of Computer
Vision, 1990. (cité pages 35, 41, 45, 55 et 98)
[129] D. Plemenos and M. S. and. M. Feixas, “On viewpoint complexity of 3d scenes,” in Proc.of
GraphiCon, 2004. (cité à la page 59)
[130] M. Pocchiola and G. Vegter, “The visibility complex,” in Proc. of SoCG, may 1993, pp. 328–
[131] F.-T. Pu, “Data structures for global illumination computation and visibility queries in 3-space,”
Ph.D. dissertation, University of Maryland, College Park, 1998. (cité pages 19, 66 et 71)
[132] S. Rivière, “Visibility computation in 2d polygonal environment,” Ph.D. dissertation, Université
Joseph Fourrier, 1997. (cité pages 40 et 43)
[133] J. Roerdink and A. Meijster, “The watershed transform : Definitions, algorithms and paral-
lelization strategies,” Fundamenta Informaticae, vol. 41, no. 1-2, pp. 187–228, 2000. (cité
pages 126 et 144)
[134] A. Rosenfeld and J. L. Pfaltz, “Sequential operations in digital picture processing,” Journal of
the ACM, vol. 13, no. 4, pp. 471–494, 1966. (cité pages 126, 131 et 136)
[135] S. Rusinkiewicz and M. Levoy, “QSplat : A multiresolution point rendering system for large
meshes,” in Proc. of Siggraph, 2000, pp. 343–352. (cité à la page 11)
[136] S. Rusinkiewicz and M. Levoy, “Streaming qsplat : a viewer for networked visualization of
large, dense models,” in Proc. of the Symp. on Interactive 3D graphics, 2001, pp. 63–68. (cité
à la page 11)
[137] P. V. Sander, X. Gu, S. J. Gortler, H. Hoppe, and J. Snyder, “Silhouette clipping,” in Proc. of
Siggraph, 2000, pp. 327–334. (cité pages 80 et 84)
[138] C. Saona-Vázquez, I. Navazo, and P. Brunet, “The visibility octree. a data structure for 3d
navigation,” Computer & Graphics, vol. 23, no. 5, pp. 635–643, 1999. (cité pages 48, 49 et 57)
BIBLIOGRAPHIE 159
[139] G. Schaufler, J. Dorsey, X. Décoret, and F. Sillion, “Conservative volumetric visibility with
occluder fusion,” in Proc. of Siggraph, 2000, pp. 229–238. (cité pages 49, 50, 52, 57 et 58)
[140] R. D. Schiffenbauer, “A survey of aspect graphs,” Polytechnic University, Brooklyn, Tech. Rep.
TR-CIS-2001-01, 2001. (cité à la page 41)
[141] J. Shade, D. Lischinski, D. H. Salesin, T. DeRose, and J. Snyder, “Hierarchical image caching
for accelerated walkthroughs of complex environments,” in Proc. of the Symp. on Interactive
3D graphics, 1996, pp. 75–82. (cité à la page 11)
[142] F. Sillion and G. Drettakis, “Feature-based control of visibility error : A multi-resolution clus-
tering algorithm for global illumination,” in Proc. of Siggraph, vol. 29, 1995, pp. 145–152. (cité
pages 54 et 146)
[143] C. Soler, “Représentations hiérarchiques de la visibilité pour le contrôle de l’erreur en simu-
lation de l’éclairage,” Ph.D. dissertation, Université Joseph Fourier (Grenoble), 1998. (cité
pages 54 et 146)
[144] C. Soler and F. Sillion, “Accurate error bounds for multi-resolution visibility,” in Proc. of Eu-
rographics Rendering Workshop, Jun 1996, pp. 133–143. (cité pages 54 et 146)
[145] A. J. Stewart, “Hierarchical visibility in terrains,” in Proc. of Eurographics Rendering Work-
shop, June 1997. (cité à la page 60)
[146] A. J. Stewart, “Fast horizon computation at all points of a terrain with visibility and shading
applications,” IEEE Transactions on Visualization & Computer Graphics, vol. 4, no. 1, pp.
82–93, March 1998. (cité pages 52 et 58)
[147] J. Stewart, “Hierarchical visibility in terrains,” Computer Graphics Forum, 1997. (cité pages 99
et 119)
[148] S. L. Stoev and W. Straßer, “Extracting regions of interest applying a local watershed transfor-
mation,” in Proc. of IEEE Visualization, 2000. (cité à la page 126)
[149] J. Stolfi, Oriented projective geometry. Academic Press Professional, Inc., 1991. (cité
pages 28 et 29)
[150] A. Sud, M. A. Otaduy, and D. Manocha, “Difi : Fast 3d distance field computation using gra-
phics hardware.” Computer Graphics Forum, vol. 23, no. 3, pp. 557–566, 2004. (cité pages 127
et 131)
[151] O. Sudarsky, “Dynamic scene occlusion culling,” Ph.D. dissertation, Technion Israel Institute
of Technology, 1998. (cité à la page 13)
[152] S. Teller and M. Hohmeyer, “Stabbing oriented convex polygons in randomized o(n2 ) time,”
Jerulsalem Combinatorics, vol. 178, pp. 311–318, 1993. (cité à la page 63)
[153] S. Teller, “Computing the antipenumbra of an area light source,” in Proc. of the Symp. on
Interactive 3D graphics, 1992. (cité pages 60, 63, 68 et 87)
[154] S. Teller, “Visibility computation in densely occluded polyhedral environments,” Ph.D. disser-
tation, UC Berkeley, CS department, 1992. (cité pages 19, 27, 37, 60, 61, 63, 84 et 137)
[155] S. Teller and P. Hanrahan, “Global visibility algorithms for illumination computations,” in Proc.
of Siggraph, vol. 27, July 1993, pp. 239–246. (cité pages 60 et 63)
[156] S. Teller and C. Séquin, “Visibility preprocessing for interactive walkthroughs,” in Proc. of
Siggraph, vol. 25, no. 4, July 1991, pp. 61–68. (cité pages 58, 60, 61 et 63)
160 BIBLIOGRAPHIE
[157] M. van de Panne and A. J. Stewart, “Effective compression techniques for precomputed visibi-
lity,” in Proc. of Eurographics Rendering Workshop, June 1999, pp. 305–316. (cité pages 14,
57, 58 et 117)
[158] G. Varadhan and D. Manocha, “Out-of-core rendering of massive geometric environments,” in
Proc. of the conference on Visualization, 2002, pp. 69–76. (cité à la page 11)
[159] I. Wald, “Realtime ray tracing and interactive global illumination,” Ph.D. dissertation, Compu-
ter Graphics Group, Saarland University, 2004. (cité à la page 91)
[160] I. Wald, A. Dietrich, and P. Slusallek, “An interactive out-of-core rendering framework for
visualizing massively complex models,” in Proc. of the Eurographics Symposium on Rendering,
2004, pp. 81–92. (cité à la page 11)
[161] Y. Wang, H. Bao, and Q. Peng, “Accelerated walkthroughs of virtual environments based on
visibility preprocessing and simplification.” Computer Graphics Forum, vol. 17, no. 3, pp. 187–
194, 1998. (cité pages 52 et 53)
[162] H. Weghorst, G. Hooper, and D. P. Greenberg, “Improved computational methods for ray tra-
cing,” ACM Transactions on Graphics, vol. 3, no. 1, pp. 52–69, 1984. (cité pages 53 et 105)
[163] I. William V. Baxter, A. Sud, N. K. Govindaraju, and D. Manocha, “Gigawalk : interactive
walkthrough of complex environments,” in Proc. of Eurographics Rendering Workshop, 2002,
pp. 203–214. (cité à la page 11)
[164] A. Wilson and D. Manocha, “Simplifying complex environments using incremental textured
depth meshes,” ACM Trans. Graph., vol. 22, no. 3, pp. 678–688, 2003. (cité à la page 11)
[165] P. Wonka, M. Wimmer, and D. Schmalstieg, “Visibility preprocessing with occluder fusion for
urban walkthroughs,” in Proc. of Eurographics Rendering Workshop, 2000, pp. 71–82. (cité
pages 51 et 60)
[166] P. Wonka, M. Wimmer, and F. Sillion, “Instant visibility,” in Proc. of Eurographics, vol. 20,
2001, pp. 411–421. (cité pages 51, 58 et 106)
[167] R. Yagel and W. Ray, “Visibility computation for efficient walkthrough of complex environ-
ments,” Presence, vol. 5, no. 1, pp. 45–60, 1996. (cité pages 49, 50 et 52)
[168] C. Yap and T. Dub’e, “The exact computation paradigm,” in Computing in Euclidian Geometry,
vol. 4, 1995, pp. 452–492. (cité à la page 95)
[169] S.-E. Yoon, B. Salomon, R. Gayle, and D. Manocha, “Quick-vdr : interactive view-dependent
rendering of massive models,” in Proc. of IEEE Visualization, 2004, pp. 131– 138. (cité à la
page 11)
[170] C. Zach and K. F. Karner, “Progressive compression of visibility data for view-dependent mul-
tiresolution meshes,” in Proc. of WSCG, 2003. (cité pages 58, 99 et 117)
[171] W. Zheng, H. Sun, H. Bao, and Q. Peng, “Rendering of virtual environments based on polygo-
nal & point-based models,” in Proc. of VRST, 2002, pp. 25–32. (cité à la page 11)

Geomertrie Descriptive

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Geomertrie Descriptive

Diunggah oleh

Hak Cipta:

Format Tersedia

Université Libre de Bruxelles

Faculté des Sciences Appliquées

Calcul et représentation de l’information de visibilité

Manuscrit présenté en vue de l’obtention du grade de

2.1.3 Description des surfaces critiques . . . . . . . . . . . . . . . . . . 37

4 Requête exacte d’occultation entre deux polygones 65

5 Précalcul de visibilité depuis les objets 97

6 Création volumique de graphes cellules-portails 123

2.3 Champ de distances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

7 Conclusions et perspectives 145

P(x1 ; :::; xd ) Point de Rd

L Point dans l’espace dual des droites, dual de la droite l

fA1 A2; ; :::; An g Ensemble de n éléments Ai

O() Complexité d’un algorithme

1 Synthèse interactive d’images

2 Visualisation interactive de scènes complexes

1 Appelées plus communément méthodes <3D temps réel>.

2.2 Aperçu des solutions existantes

3 Elimination des surfaces non visibles

F IG . 1.1: Processus d’affichage classique à l’aide de l’algorithme du <z-buffer>.

3.2 Méthodes d’<occlusion culling>

3.2.1 <Occlusion culling> en ligne

3.2.2 <Occlusion culling> avec précalcul

F IG . 1.4: Comparaison du temps de calcul des diff érentes techniques.

4 Objectifs de notre étude

lors de la phase d’exploration interactive.

Nous décrivons dans le chapitre 4 un algorithme permettant de déterminer de manière exacte si

Finalement, le chapitre 7 présente les conclusions et les perspectives de développement futur de

2 Introduction aux polyèdres

F IG . 2.1: Un hyperplan H sépare l’espace en deux demi-espaces ouverts H + et H - .

F IG . 2.2: Polytope 2D (a) H-représentation du polytope. (b) V-repr ésentation du polytope.

2.2 Faces d’un polyèdre et description combinatoire

2.3 Graphe d’incidence et 1-squelette

2.4 Complexe de polyèdres et arrangement d’hyperplans

F IG . 2.5: Arrangement d’hyperplans. P i est un polyèdre, délimité par un sous-ensemble d’hyperplans de H .

2.5 Graphe dual

3 Espace dual et coordonnées de Plücker

3.1 Représentation d’une droite dans un espace dual

3.2 Coordonnées de Plücker

3.2.1.1 Exemple 1 : droites poignardant un segment de R2 Dans ce premier exemple, nous

(a) Espace primal (b) Espace dual des droites(après projection)

3.2.1.3 Exemple 3 : droites poignardant k polygones convexes dans R3 Considérons mainte-

3.2.2 Définition mathématique des coordonnées de Plücker

3.2.3 Coordonnées de Plücker dans R2 [23]

Espace dual de Plücker (2D)

3.2.4 Coordonnées de Plücker dans R3

Espace dual de Plücker (5D)

F IG . 2.12: Position relative des droites a et b en utilisant l’espace de Pl ücker 3D.

des droites orientées [43].

2.1 Graphe d’aspect et partition <VSP>

2.1.2 Frontières entre régions d’aspect constant

2.1.3 Description des surfaces critiques

point il passe au moins une droite entièrement contenue dans la surface.

ponctuelles appelées droites poignardantes extrêmes10 .

– entre 4 arêtes de différents polygones (droite EEEE).

2.1.4 Utilisation du graphe d’aspect pour le calcul de vues

2.2 La structure de données <Asp>

2.3 Arrangement d’hyperplans dans l’espace de Plücker

2.4 Méthodes de visibilité globales

2.4.1 Complexe de visibilité

2.4.2 Squelette de visibilité

(a) (b) (c)

3 Encodage de la visibilité sous la forme de <PVS>