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 plateforme 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.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.nodecomponent 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
Public class Hello extends Applet { public Hello() { Programme simple 1/3 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 java.awt.borderlayout; import java.awt.frame; import java.awt.event.*; import com.sun.j3d.utils.applet.mainframe; import com.sun.j3d.utils.universe.*; import com.sun.j3d.utils.geometry; import javax.media.j3d.*; import javax.vecmath.*; 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 T3D rotate Objet ColorCube
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