graphe de scene.

Java3D
Généralités sur la synthèse d'images temps réel
Généralités sur Java3D
d 'après P.Reignier, UJF
Généralités sur la 3D
Pourquoi utiliser une représentation en 3D ?

Réalisme

Compréhension accrue d'un modèle à 3 dimensions
=> travail du système perceptif humain plutôt que du système cognitif

Représentations des molécules en chimie

Mouvement des astres en astronomie

Topographies de terrains en cartographie

Représentation d'organes en médecine

Interactions riches et intuitives avec de multiples données
Synthèses d'images : API bas niveau
Aspect matériel : facultatif mais fortement conseillé


Stations spécialisées : SGI, Sun, HP, IBM
Cartes accélératrices : PC, Mac (dans une moindre mesure)

Aspect logiciel


APIs
API bas niveau
Interface avec le matériel

Emule le matériel inexistant

Très bas niveau d'abstraction :

Sommets, faces

Processus de rendu

Exemples :

OpenGL : standard multi OS, multi machines

Direct3D IM : Windows

API haut niveau
S'appuient sur les APIs bas niveau

Haut niveau d'abstraction :

Objets par opposition à sommets

Contenu par oppostion à processus de rendu

Graphe de scènes

Exemples :

Open Inventor, Performer, OpenGL Optimizer, Java 3D

Direct3D RM

Construction avion : graphe de scène
Scène 3D : hiérarchie d'objets => notion de graphe de scène

Exemple : éléments constituant la scène

Construction avion : graphe de scène
On commence à regrouper les éléments

Construction avion : graphe de scène
On finit l'avion

Construction avion : graphe de scène

Le graphe de scène
Graphe de scène : plusieurs objets
Java3D ?
API destinée à l'affichage 3D sous Java : développée par SUN en 1998

Java 3D destinée à l'écriture d'applications et d'Applets.

Conçue dans le but de faciliter la programmation :

Classes pour la création de scènes 3D

Classes pour la manipulation de ces scènes

Justifiée par la portabilité de Java qui permet la portabilité des applications Java 3D sur toute plate­
forme où Java existe (Solaris, Windows) : accès à tous les packages Java

Rendu3D
Rendu haute performance

Utilisation de l'accélération 3D matérielle si possible

Basé sur :

OpenGL

Direct3D 
Applications
Visualisation scientifique

Visualisation d'informations

Entraînement médical

Système d'information géographique

CAO

etc

Visualisation scientifique
Visualisation médicale
Conception Assistée par Ordinateur
Java3D

Introduction

Organisation d'une scène : Graphe de scène

Ecrire un programme Java3D

Les classes principales

Un peu d'animation
API Java3D

Chaque programme Java3D est assemblé à partir d'objets provenant des classes Java3D :
−
Plus de 100 classes et des centaines de méthodes et champs présents dans le package javax.media.j3d appelé aussi core package
−
D'autres packages sont utilisés :
Classes d'objets fonctionnels : com.sun.j3d.utils

Classes d'outils de fenêtrage (AWT) : java.awt

Classes d'objets mathématiques : javax.vecmath


Cette collection d'objets décrit un univers virtuel « virtual universe » qui représente ce qui est rendu
Graphe de scène (Scene Graph)


L'« univers virtuel » java3D est créé à partir d'un graphe de scènes :
−
Feuilles : formes 3D, lumières, sons, comportements, ..
−
Parents : groupe d'enfants, transformation 3D, ..
2 points de vue :
−
Développeur : construction et mise à jour d'un graphe à l'aide des classes et des méthodes Java3D
−
Java3D : rendu à l'écran du contenu du graphe (moteur de rendu : Z­Buffer + ombrage de Gouraud)
Rendu du graphe


Ordre du parcours du graphe : choisi par Java3D
Rendu via des threads indépendants et asynchrones: −
Graphique (objets)
−
Fonctionnalités classiques : brouillard, antialiassage, ...
−
Son
−
Comportement (« behaviors ») −
Animation (« interpolators »)
−
Périphériques d'entrée­sortie
−
Événements (détection de collision)
Graphe de scènes
Représentation et terminologie
Graphe de scènes
Représentation et terminologie
Graphe de scènes
Représentation et terminologie

Univers Virtuel (virtual universe) : Collection de graphes de scènes
Un par application (possibilité d'en avoir 2, mais aucune com) 
C'est le sommet du graphe


Repère (Locale) : généralement un par univers

Graphe de scènes : généralement plusieurs par repère

Noeuds (nodes)
−
Groupe (group) : peut avoir plusieurs enfants mais un seul parent (ex: BranchGroup, TransformGroup)
−
Feuille (Leaf) : un seul parent et aucun enfant (ex : Shape3D, Light, Behavior, Sound)
Graphe de scènes
Représentation et terminologie
Graphe de scènes
Représentation et terminologie


Composant du Noeud (NodeComponent)
−
Définit les attributs géométriques et d'apparence utilisés pour le rendu des objets décrits par le noeud du graphe qui lui est associé (ex : texture, matériel, géométrie)
−
Ne fait pas partie du graphe de scènes
2 types d'arcs :
−
« parent­enfant » : lie les noeuds de l'arbre du graphe
−
« référence » : lie un noeud de l'arbre à un objet NodeComponent

N'appartient pas à l'arbre du graphe de scènes

Graphe de scènes
Représentation et terminologie

BranchGroup : racine d'un sous­graphe ou graphe de branches

2 types de branches (Branch Graph) :
−
Branche de scènes (content branch graph) :
Spécifie les contenus de l'univers virtuel (Node et NodeComponent) : géométrie, apparence, comportement, emplacement dans la scène, son, lumières

Plusieurs par univers

−
Branche de visualisation (view branch graph) :
Spécifie les paramètres de visualisation : emplacement de vision, direction de vision

Généralement une par univers 
Aperçu de la hiérarchie de classes

class java.lang.Object
−
class javax.media.j3d.VirtualUniverse
−
class javax.media.j3d.SceneGraphObject

class javax.media.j3d.Node
−
−

class javax.media.j3d.NodeComponent
−
−
−
class javax.media.j3d.Group

class javax.media.j3d.BranchGroup

class javax.media.j3d.Switch
class javax.media.j3d.Leaf

class javax.media.j3d.Background

class javax.media.j3d.Behavior
class javax.media.j3d.Geometry
class javax.media.j3d.Appearance
class javax.media.j3d.View
Ecrire un programme Java3D
 Créer un objet Canvas3D (fournit une image dans la fenêtre d'affichage)
Créer un objet VirtualUniverse
 Créer un objet Locale, l'attacher à l'objet VirtualUniverse
4. Construire un graphe de branche de visualisation :
− Créer un objet View, ViewPlatform, PhysicalBody, PhysicalEnvironment
− Attacher les objets ViewPlatform, PhysicalBody, PhysicalEnvironment, Canvas3D à l'objet View
5. Construire le(s) graphe(s) de branche de scène
6. Compiler les graphes de branche
Insérer les sous­graphes dans le repère Locale Programme simple
la classe SimpleUniverse


la classe SimpleUniverse (com.sun.j3d.utils.universe) va permettre de décrire les points 2, 3, et 4
Le constructeur de l'objet SimpleUniverse crée un graphe de scène incluant :

les objets VirtualUniverse et Locale
un graphe de branche de visualisation complet
On rattache le Canvas3D à l'objet View en passant Canvas3D en paramètre au constructeur.



Le graphe de branche de visualisation créé inclut un plaqué de l'image (« image plate »)
SimpleUniverse
y
z
x
Programme simple
la classe ViewingPlatform



La classe SimpleUniverse a un objet appartenant à la classe ViewingPlatform
La classe ViewingPlatform a une méthode setNominalViewingTransform() qui positionne les yeux à (0,0,2.41). A cette distance et dans un champ de vue par défaut, les objets de hauteur et largeur de 2m « tiennent » dans le plaqué.
On récupère l'objet ViewingPlatform créé par le SimpleUniverse grâce à la méthode de la classe SimpleUniverse :
−
ViewingPlatform getViewingPlatform()
Programme facile
graphe de branche de scènes



La régularité de structure n'existe pas pour les graphes de branche de scènes
On crée un BranchGroup par branche de scène qui est ajouté au graphe comme fils de l'objet Locale (créé par le SimpleUniverse) :
−
void addBranchGroup(BranchGroup bg)
−
Lorsque l'objet est ajouté, on dit qu'il est « vivant »
Les objets BranchGroup peuvent être compilés afin de convertir l'objet et tous ses ancêtres en une forme plus efficace pour le renderer :
−
void compile()
Exemple
Programme simple 1/3
Public class Hello extends Applet { public Hello() {
setLayout(new BorderLayout()); //permet de créer la fenêtre de vision
1. GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
Canvas3D canvas3D = new Canvas3D(config);
add("Center",canvas3D);
2/3/4. SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
//on place les objets pour qu'ils soient vus simpleU.getViewingPlatform().setNominalViewingTransform(); 5.
BranchGroup scene = createSceneGraph();
6.
scene.compile();
7.
simpleU.addBranchGraph(scene);
}
Programme simple 2/3
construction d'un graphe de scene
public BranchGroup createSceneGraph() {
BranchGroup objRoot = new BranchGroup(); //crée la racine du graphe
objRoot.addChild(new ColorCube(0.4)); //création d'un objet simple
return objRoot;
}
public static void main(String[] args) {
//permet de fournir un cadre pour une applet (ici : « Hello() ») pour pouvoir l'exécuter comme une application 3D (dans une fenêtre)
Frame frame = new MainFrame(new Hello(), 256, 256); }
}
Programme simple 3/3
packages utilisés
La plupart des classes utilisées en Java3D se trouvent dans les packages :

javax.media.j3d

javax.vecmath


Dans la plupart des programmes Java3D on retrouvera les packages suivants :
import java.applet.Applet;
import com.sun.j3d.utils.universe.*;
import java.awt.BorderLayout;
import com.sun.j3d.utils.geometry;
import java.awt.Frame;
import javax.media.j3d.*;
import java.awt.event.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;
http://download.java.net/media/java3d/javadoc/1.3.2/overview­summary.html
Transformations des objets
classe Transform3D 1/2





Les objets Transform3D représentent des transformations de géométrie 3D (rotation, ...)
Ces objets ne sont utilisables que dans le cadre d'une création d'un objet TransformGroup
Les objets Transform3D peuvent être combinés
Ces objets sont représentés en interne comme des matrices 4x4 de flottants en double précision ligne par ligne
Le constructeur Transform3D() construit la matrice identité
Transformations des objets
classe Transform3D 2/2

Transformations de base :
−
rotX(double angle), rotY(angle), rotZ(angle) où l'angle est spécifié en radians 
La rotation autour des axes se fait dans le sens des aiguilles

La valeur de pi est donnée par la constante Math.PI

−
set (params) où params peut être par exemple :
Vector3f translate : alors seuls les composants de la matrice identité correspondant à la translation sont modifiés 
double scale : met les valeurs de la transformée à une échelle uniforme ; toutes les valeurs de la matrice sont modifiées

Transformations des objets
classe TransformGroup


La classe TransformGroup permet d'appliquer des transformations sur tous les objets de son sous­graphe. On passe l'objet Transform3D :
−
à la création : TransformGroup(Transform3D t)
−
ou en utilisant la méthode set(Transform3D t) après l'avoir construit par TransformGroup()
Transformations des objets
exemple : rotations d'un cube 1/2
1. créer la transformation : une rotation « tmpRotate » par rapport à Oy, précédée d'une rotation « rotate » par rapport à Ox, la combinaison finale étant représentée par « rotate »
Transform3D rotate = new Transform3D();
rotate.rotX(math.PI/4.0d);
Transform3D tmpRotate = new Transform3D();
tmpRotate.rotY(math.PI/5.0d);
rotate.mul(tmpRotate);
2. Rattacher la transformation au TransformGroup TransformGroup objRotate = new TransformGroup(rotate);
Transformations des objets
exemple : rotations d'un cube 2/2
3. Rattacher l'objet « ColorCube » (sur lequel la transformation va être appliquée) comme fils du TransformGroup
objRotate.addChild(new ColorCube(0.4));
4. Rattacher le TransformGroup à son parent le BranchGroup
BranchGroup objRoot = new BranchGroup();
objRoot.addChild(objRotate);
Exemple
représentation du graphe de scène
BG
objRoot
TG
objRotate
Objet
ColorCube
T3D
rotate
Performances


Le graphe de scène construit par un programme Java3D pourrait être utilisé directement en rendu, mais la représentation n'est pas très efficace => utilisation d'une représentation interne pour l'univers virtuel qui est obtenue par :
−
Compilation du graphe de la branche avec compile()
−
Insertion du graphe de la branche dans l'univers virtuel pour le rendre « vivant » A chacune de ces actions correspond une méthode dans la classe SceneGraphObject renvoyant un booléen : isCompiled(), isLive()
Capacités (« capabilities »)

Les effets de la transformation du graphe en représentation interne sont de :
Fixer les valeurs des transformations et d'autres objets

Mais il y a des cas où on a besoin de changer les valeurs dans le graphe de scène de l'objet après qu'il soit devenu « vivant » (exemple : pour réaliser des animations un objet TransformGroup doit avoir des valeurs différentes) 


On appelle la liste des paramètres ayant des valeurs modifiables les capacités de l'objet (varie en fonction de la classe)
Chaque graphe de scène a un ensemble de bits de capacité dont les valeurs déterminent quelles capacités existent pour l'objet « vivant »
Exemples de capacités

Capacités de la classe TransformGroup :
−
2 et seulement 2 qui spécifient que le TransformGroup permet d'accéder/modifier les informations de transformations de cet objet
ALLOW_TRANSFORM_READ : accès

ALLOW_TRANSFORM_WRITE : modifier

−

TransformGroup hérite des capacités de ses parents
Capacités de la classe Group :
ALLOW_CHILDREN_EXTEND : les enfants peuvent être ajoutés au noeud après qu'il ait été compilé

ALLOW_CHILDREN_READ : permet de lire les références aux enfants de ce noeud

Un peu d'animation ...
la classe Behavior




Behavior permet de spécifier :
−
des animations d'objets visuels (réponses au temps qui passe)
−
ou des interactions entre ces objets (réponses aux activités de l'utilisateur)
Le behavior peut changer virtuellement tout attribut d'un objet visuel :
−
Plusieurs behavior prédéfinis existent −
On peut créer son propre behavior
Une fois que le behavior est spécifié, le système Java3D met à jour les position, couleur, ...
Un objet visuel peut avoir plusieurs behavior
Un peu d'animation ...
Behavior comment ?


Pour spécifier un behavior pour un objet visuel :
−
Créer les objets que spécifie le behavior
−
Ajouter l'objet visuel au graphe de scène
−
Faire les références appropriées parmi les objets du graphe et les objets du behavior
−
Exemple de behavior : Interpolator basée sur le temps
Pour éviter la surcharge de calculs, un behavior aura une zone d'action (« scheduling region») et il sera actif seulement lorsque sa zone d'action intersectera le volume d'activation de la zone de vision ViewPlatform
Un peu d'animation
les étapes
 Créer un TransformGroup cible
mettre la capacité ALLOW_TRANSFORM_WRITE
 Créer un objet Alpha
spécifier les paramètres de temps pour alpha
 Créer un objet Interpolator
lui faire référencer les objets Alpha et TransformGroup
adapter les paramètres du behavior
 Spécifier une zone d'action
la rattacher au behavior
5.Lier le behavior comme enfant du TransformGroup
Un peu d'animation ...
Exemple : RotationInterpolator

Interpolator permet de réaliser différentes actions, on parle de ixInterpolator où ix est remplacé par :


Position (position), Rotation (orientation), Scale (taille), Color
(couleur), Transparency (transparence)
RotationInterpolator :
−
change un objet TransformGroup en une rotation spécifique en réponse à la valeur d'un objet Alpha −
Peut spécifier l'axe de rotation, l'angle de départ, l'angle d'arrivée
−
Constructeur RotationInterpolator(Alpha alpha, TransformGroup target) Un peu d'animation ...
le temps et la zone d'action


Classe Alpha fournit des objets pour convertir le temps en une valeur alpha (valeur entre 0 et 1) : la fonction f(t) et les caractéristiques de l'objet Alpha peuvent être données par l'utilisateur via les méthodes de la classe :
−
Constructeur Alpha() : boucle continue pendant 1s
−
Constructeur Alpha(int loopCount, long alphaDuration) : ceci est répété autant de fois que la valeur de loopCount (si=­1=> infini) avec une durée de alphaDuration (en ms) entre le début et la fin
Pour définir la zone d'action on utilise la méthode setSchedulingBounds (de la classe Behavior) avec en paramètre le type de zone : on utilise souvent l'objet BoundingSphere (constructeur BoundingSphere() de rayon 1) dont on peut spécifier le centre et le rayon
Exemple : rotation du cube coloré
HelloUniverse3Dc.java
Un peu d'animation ...
les étapes : exemple de fonction
public BranchGroup createSceneGraph() {
BranchGroup objRoot = new BranchGroup();
1. TransformGroup objSpin = new TransformGroup();
objSpin.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
objRoot.addChild(objSpin);
objSpin.addChild(ColorCube(0.4));
2. Alpha rotationAlpha = new Alpha(­1, 4000);
3.
RotationInterpolator rotator = new RotationInterpolator(Alpha, objSpin);
4.
rotator.setSchedulingBounds(new BoudingSphere());
5.
objSpin.addChild(rotator);
return objRoot;
}
Exemple
représentation du graphe de scène