Figuras Geométricas


Sistema de Coordenadas

EL sistema de coordenadas del universo en Java3D se representa según un sistema cartesiano, que sigue la "regla de la mano derecha", como se observa en el siguiente diagrama:


Shape3D

Una instancia del objeto Shape3D define un objeto visual. La clase Shape3D es una subclase de la clase Leaf, luego, solamente puede estar presente en el grafo, como una hoja.

El objeto Shape3D no tiene información sobre la forma o el color del objeto, peor puede referenciar un Nodo Componente Geometry y un Nodo Componente Appearance. Los Nodos Componentes Gemoetry permiten definir la geometría de la figura, y los Nodo Componentes Appearance sirven para definir las características de la apariencia del objeto. En el grafo, esto se representa:


Para crear los objetos, es útil crear una clase para definir las características del objeto visual. El patrón general es:

public class VisualObject extends Shape3D{ 

	private Geometry voGeometry; 
	private Appearance voAppearance; 
 
	// create Shape3D with geometry and appearance 
	// the geometry is created in method createGeometry 
	// the appearance is created in method createAppearance 
	public VisualObject() { 
	 
		voGeometry = createGeometry(); 
		voAppearance = createAppearance(); 
		this.setGeometry(voGeometry); 
		this.setAppearance(voAppearance); 
	} 
	
	private Geometry createGeometry() { 
		// code to create default geometry of visual object 
	}
	 
	private Appearance createAppearance () { 
		// code to create default appearance of visual object 
	} 
	 
} // end of class VisualObject

Después, este objeto puede ser agregado a un nodo: 

objRoot.addChild (new VisualObject());

Con esto, es posible definir figuras geométricas específicas, según las necesidades del usuario.

Figuras Utiles

En Java3D también existen clases de objetos gráficos que permiten generar figuras geométricas primitivas. En estas primitivas, no se puede modificar la geometría de la figura, pero sí es posible modificar la apariencia y su tamaño.

Las figuras geométricas primitivas son:


Sus constructores son:

Box (float xdim, float ydim, float zdim)
crea una caja de dimensiones xdim * ydim * zdim, centrada en el origen
Cone (float r, float h)
crea un cono de radio r y altura h, centrada en el origen alineada según el eje y
Cylinder (float r, float h)
crea un cilindro de radio r y altura h, centrada en el origen con su eje principal según el eje y
Sphere (float r)
crea una esfera de radio r, centrada en el origen

Todos estos objetos tienen en común, entre otros, el método:

void setAppearance (Appearance ap)
que permite definir la apariencia de la figura, haciendo referencia a otro Nodo Componente Appearance.

Ejemplo: Dibujar un yo-yo, utilizando 2 conos. Para esto, es necesario rotar ambos conos segun el eje z, y luego trasladarlos según el eje x.

El grafo se vería como:


y el código sería:

public class ConeYoyo{ 
 
	private BranchGroup yoyoBG; 
 
	// create Shape3D with geometry and appearance 
	public ConeYoyo() { 
	
		yoyoBG = new BranchGroup(); 
		Transform3D rotate = new Transform3D();
		Transform3D translate = new Transform3D(); 
		Appearance yoyoAppear = new Appearance(); 
		
		rotate.rotZ(Math.PI/2.0d); 
		TransformGroup yoyoTGR1 = new TransformGroup(rotate); 
	
		translate.set(new Vector3f(0.1f, 0.0f, 0.0f)); 
		TransformGroup yoyoTGT1 = new TransformGroup(translate); 
	
		Cone cone1 = new Cone(0.6f, 0.2f); 
		cone1.setAppearance(yoyoAppear); 
	
		yoyoBG.addChild(yoyoTGT1); 
		yoyoTGT1.addChild(yoyoTGR1); 
		yoyoTGR1.addChild(cone1); 
	 
		translate.set(new Vector3f(-0.1f, 0.0f, 0.0f)); 
		TransformGroup yoyoTGT2 = new TransformGroup(translate); 
		
		rotate.rotZ(-Math.PI/2.0d); 
		TransformGroup yoyoTGR2 = new TransformGroup(rotate); 
	
		Cone cone2 = new Cone(0.6f, 0.2f); 
		cone2.setAppearance(yoyoAppear); 
	
		yoyoBG.addChild(yoyoTGT2); 
		yoyoTGT2.addChild(yoyoTGR2); 
		yoyoTGR2.addChild(cone2); 
	
		yoyoBG.compile(); 
	 
	} // end of ConeYoyo constructor 
 
	public BranchGroup getBG(){ 
		return yoyoBG;
	} 
	 
} // end of class ConeYoyo

y la figura que se obtiene es:


GeometryArray

Es una clase abstracta que permite definir puntos, líneas y polígonos (triángulos y cuadriláteros). Entre las clases que extienden a GeometryArray están:


Estas subclases se obervan en el siguiente diagrama:


Sus constructores son:


vertexCount es la cantidad de vértices que conforman la figura, y vertexFormat es un conjunto de flags que determinan ciertas características de la figura.

Después de crear el objeto, es necesario empezar a llenarlo con la información de las coordenadas de sus vértices.

La clase GeometryStripArray es una clase abstracta, de la cual se derivan varias clases que permiten reusar los vértices definidos. Estas subclases son:



Appearance

Los objetos de Shape3D, así como referencian Nodos Componentes de Geometry, también pueden referenciar Nodos Componentes de Appearance. Al referenciar a los nodos de Appearance, permiten describir como se "ven" los objetos. Además permite que varios objetos de Shape3D referencien al mismo nodo Appearance, haciendo que los objetos de "vean" similares.

Los nodos de Appearance pueden referenciar a varios tipos de Nodos Componentes como:


Para estos nodos, se utilizan los siguientes constructores:

PointAttributes (float pointSize, boolean state)
Crea un Nodo Componente que describe el tamaño del punto, y si habilitar o no anti-aliasing
LineAttributes (float pointSize, int linePattern, boolean state)
Crea un Nodo que describe la línea, de grosor pointSize, el patrón ha usar para dibujarla, y si habilitar o no el anti-aliasing
PolygonAttributes (int polygonMode, int cullFace, float polygonOffset, boolean backFaceNormalFlip)
Crea un Nodo que determina si el polígono va a ser dibujado con puntos, líneas, o polígonos rellenos; mostrar ambas caras o no; la profundidad del polígono; y si generar las normales para la cara reversa
ColoringAttributes (float red, float green, float blue, int shadeModel)
Crea un Nodo para describir el color (con los valores de red, green y blue), y determinar la forma de sombrear la figura

Al definir el Nodo Appearance, se determina las características de apariencia que va a tener el objeto que hace referencia al nodo.