Unidad 3 Trabajando Con Un API Grafica PDF

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD
Escuela de Ciencias Bsicas, Tecnologa e Ingeniera

Ingeniera de Sistemas Mdulo del curso Computacin Grfica

UNIDAD 3 TRABAJANDO CON UN API GRFICA .................................................................................... 3
CAPTULO 7 Fundamentos del API 2D de JAVA ..................................................................... 6
Leccin 31 Caractersticas generales del API 2D de Java .............................................................. 6
Leccin 32 Ubicacin espacial, textos e imgenes ...................................................................... 10
Leccin 33 Rellenos, Filetes y Composiciones ............................................................................. 15
Leccin 34 Los paquetes del API 2D de Java ............................................................................... 17
Leccin 35 La clase Graphics ....................................................................................................... 20
CAPTULO 8 API 3D de JAVA ................................................................................................... 24
Leccin 36 Figuras bsicas en Java 2D (Shape) ........................................................................... 24
Leccin 37 reas .......................................................................................................................... 36
Leccin 38 Texto y Fuentes ......................................................................................................... 40
Leccin 39 Imgenes ................................................................................................................... 47
Leccin 40 Tcnica de Doble Bfer ............................................................................................. 54
CAPTULO 9 API 3D de JAVA ................................................................................................... 61
Leccin 41 Lo bsico de Java 3D .................................................................................................. 62
Leccin 42 Empezar con Java 3D ................................................................................................. 62
Leccin 43 Un Ejemplo de la aplicacin de la receta .................................................................. 76
Leccin 44 Rotacin de objetos .................................................................................................. 82
Leccin 45 Aadir Comportamiento de Animacin .................................................................... 90


ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO

El contenido didctico del curso acadmico Computacin Grfica fue diseado
inicialmente en el ao 2005 por Adriana roco Lizcano Dallos, docente de la UNAD,
Bogot, ingeniera de sistemas, en su desempeo como tutora.
Se han realizado las siguientes actualizaciones al contenido didctico:
Adecuacin del diseo segn plantilla material didctico UNAD.
Distribucin de unidades, captulos y lecciones segn el estndar CORE.
Adicin del captulo 4 Requerimientos de software.
Actualizacin de herramientas para el desarrollo, codificacin y libreras.

Estos cambios fueron realizados por Oscar Javier Abaunza Garca, docente de la
UNAD, CEAD Bucaramanga, ingeniero de sistemas, especialista en educacin
superior a distancia, en su desempeo como tutor y director del curso a nivel
nacional.


UNIDAD 3 TRABAJANDO CON UN API GRFICA
Introduccin
En los captulos anteriores nos hemos acercado al mundo de la computacin
grfica conociendo sus bases conceptuales y haciendo pequeos programas que
permiten dibujar en la pantalla a partir de la unidad bsica de dibujo: el pxel. En
esta Unidad deseamos introducir el manejo de una API grfico. Como se
mencionaba en la primera unidad las API grficas proporcionan un conjunto de
primitivas independientes del hardware que le facilitan el proceso de dibujo
computacional, algunas de ellas, como OpenGL son muy utilizadas por dos
razones: su potencial y la libre distribucin.
El lenguaje de programacin Java proporciona como parte de su conjunto de
clases fundamentales para la creacin de interfaces grficas de usuario, un
conjunto de clases denominado Java 2D.
El API 2D de Java introducido en el JDK 1.2 proporciona grficos avanzados en
dos dimensiones, texto, y capacidades de manejo de imgenes para los programas
Java a travs de la extensin del AWT. Este paquete de dibujo soporta lneas
artsticas, texto e imgenes en un marco de trabajo flexible y lleno de potencia para
desarrollar interfaces de usuario, programas de dibujo sofisticados y editores de
imgenes.
El API 2D de Java proporciona:
Un modelo de renderizado uniforme para pantallas e impresoras.
Un amplio conjunto de grficos primitivos geomtricos, como curvas,
rectngulos, y elipses y un mecanismo para renderizar virtualmente
cualquier forma geomtrica.
Mecanismos para detectar esquinas de formas, texto e imgenes.
Un modelo de composicin que proporciona control sobre cmo se
renderizan los objetos solapados.
Soporte de color mejorado que facilita su manejo.
Soporte para imprimir documentos complejos.
Durante el primer captulo de esta Unidad didctica se cubrirn los tpicos
correspondientes a la graficacin en 2D mediante el uso del API 2D de Java, a
partir de la recopilacin de dos documentos de internet que son magnficos puntos
de referencia: El tutorial sobre grficos en Java de Agustn Froufe y el curso de
Java en Castellano traducido por Juan Antonio Palos (ozito).


En cuanto al dibujo (o renderizado) en 3D, El API Java 3D es un interface para
escribir programas que muestran e interactan con grficos tridimensionales. Java
3D es una extensin estndar del JDK 2 de Java. El API Java 3D proporciona una
coleccin de constructores de alto-nivel para crear y manipular geometras 3D y
estructuras para dibujar esta geometra. Java 3D proporciona las funciones para
creacin de imgenes, visualizaciones, animaciones y programas de aplicaciones
grficas 3D interactivas. En el segundo captulo de esta Unidad se proporcionan los
elementos fundamentales para asumir el estudio del API Java 3D, proporcionando
algunos ejemplos bsicos. Para el desarrollo de esta parte de la Unidad se ha
recopilado nuevamente la informacin proporcionada por Juan Antonio Palos
(ozito).
Esta unidad final del curso de Computacin Grfica quiere acercarlo an ms a la
visualizacin de grficos computacionales. Aunque se reconoce que la informacin
que se proporciona es bastante limitada, los lmites se los impone su creatividad y
sus deseos de realizar nuevas cosas. En la seccin de Enlaces relacionados podr
encontrar enlaces con una gran cantidad de informacin adicional, para ayudarlo a
hacer volar su imaginacin.
La implementacin de buena parte de los ejemplos requiere que usted conozca con
anticipacin los fundamentos bsicos de la clase Awt o Swing de Java, si quiere
repasarlos, revise la seccin de enlaces.

Intencionalidades Formativas
Propsitos
Introducir al estudiante en el conocimiento de los principales algoritmos y
estructuras de datos utilizados en Computacin Grfica, especialmente en la
generacin de grficos en dos dimensiones.
Proporcionar al estudiante los lineamientos tecnolgicos bsicos que le
permitan utilizar API grficas en conjunto con lenguajes de programacin de
alto nivel, para el proceso de modelamiento y construccin de escenarios
grficos en 2D y 3D.
Objetivos
Programar ejercicios de llenado de reas y transformaciones de figuras en
dos dimensiones, utilizando libreras grficas y lenguajes de programacin,
partiendo de la conceptualizacin geomtrica respectiva.


Emplear los fundamentos necesarios para la construccin de aplicaciones
que presenten objetos grficos en dos dimensiones, mediante la
funcionalidad que proporciona el paradigma orientado a objetos y el API
Java 2D.
Identificar algunas de las potencialidades para el dibujo y animacin de
escenarios grficos en tres dimensiones, a partir de la programacin de
ejemplos bsicos que utilizan el API Java 3D.
Competencias
El estudiante programa y emplea algoritmos que permiten dibujar las
principales figuras geomtricas en dos dimensiones.
El estudiante conoce los fundamentos matemticos de la representacin de
grficos computacionales en dos dimensiones y utiliza algoritmos que las
realizan.
El estudiante utiliza las principales clases proporcionadas por el API 2D y 3D
de Java, en la programacin de ejercicios que exigen la representacin de
grficos en dos y tres dimensiones.
Metas
Al finalizar esta unidad didctica el estudiante estar en capacidad de:
Usar API grficas para la construccin de grficos computacionales.
Utilizar y construir algoritmos para dibujo de grficos en 2D y 3D.
Describir el funcionamiento matemtico y geomtrico que permite el
dibujo de grficos en el computador.

Mapa Conceptual de la Unidad


Productos de Aprendizaje
Individual
Lectura autorregulada de la Unidad Didctica realizando fichas textuales y
mapas conceptuales para archivar en el portafolio.
Consultar en internet sobre los temas de la unidad y publicar preguntas en el
foro de la unidad correspondiente para que sean solucionadas por el tutor o
los compaeros.
Sustentacin individual de los programas desarrollados en JAVA.
Pequeo Grupo Colaborativo
Desarrollo de un proyecto de programacin utilizando texturas e iluminacin con el
API 3D. Los enunciados sern entregados por el tutor indicando las fechas y
condiciones de entrega.
Grupo de Curso
Por cada tipo de algoritmo que se estudia se realizar una prctica en
computadores, para repasar los conceptos bsicos y probar los algoritmos
codificados en JAVA.
Socializacin de los productos individuales y en pequeo grupo colaborativo.
Consolidacin de conceptos, glosario tcnico y mapa conceptual de la
unidad.

CAPTULO 7 Fundamentos del API 2D de JAVA
Leccin 31 Caractersticas generales del API 2D de Java

31.1 Caractersticas generales del API 2D de Java
A continuacin se presentan algunas de las caractersticas del API 2D de Java, a
partir de la documentacin proporcionada por Sun Microsystems para el J2SE.
El API 2D de Java mejora las capacidades de grficos, texto e imgenes de la
Abstract Windowing Toolkit (AWT), haciendo posible el desarrollo de interfaces de
usuario mejoradas y nuevos tipos de aplicaciones Java. Adems de sus mejoras en
grficos, letra e imgenes, el API 2D de Java soporta mejoras para la definicin y
composicin del color, adems de la deteccin de formas y texto en formas


geomtricas arbitrarias y un modelo de dibujado (rendering) para impresoras y
dispositivos de visualizacin.
El API 2D de Java tambin hace posible la creacin de libreras grficas
avanzadas, tales como libreras de CAD-CAM y de grficos o libreras de efectos
especiales para imgenes, as como la creacin de imgenes y de filtros para
archivos grficos.
Cuando se usa en conjunto con al Java Media Framework y otras APIs de Java
Media, el API 2D de Java puede utilizarse para crear y visualizar animaciones y
otras presentaciones multimedia. Los APIs de Java Animation y Java Media
Framework le proporcionan al API 2D de Java el soporte para el renderizado.

31.1.1 Mejoras de grficos, texto e imgenes
Las ltimas versionas del AWT proporcionaron un paquete simple para construir
pginas comunes HTML, pero no contemplaban caractersticas completas
suficientes para dibujar grficos complejos, texto e imgenes. Como un paquete de
dibujo simplificado, el AWT encapsul casos especficos de conceptos de
renderizado ms general. El API 2D de Java provee una paquete de renderizado
ms flexible y con amplias caractersticas que expanden el AWT para soportar
grficos generales y operaciones de renderizado.
A travs de la clase Graphics, es posible dibujar rectngulos, elipses y polgonos.
El Graphics2D incorpora el concepto de renderizado geomtrico proporcionando un
mecanismo para dibujar virtualmente cualquier forma geomtrica. Igualmente, con
el API Java 2D es posible dibujar lneas con estilos, de cualquier ancho y formas
geomtricas rellenas con virtualmente cualquier textura.
Las formas geomtricas se proporcionan a travs de implementaciones de la
interfaz Shape, por ejemplo las figuras Rectangle2D y Ellipse2D. Las curvas y los
arcos tambin son implementaciones especficas de la interfaz Shape.
Los rellenos y estilos de lpiz (denominado Filete en mltiples aplicaciones de
dibujo) se proporcionan a travs de implementaciones de las interfaces Paint y
Stroke, por ejemplo: BasicStroke, GradientPaint, TexturePaint y Color.
La implementacin AffineTransform define transformaciones lineales de
coordenadas 2D, incluyendo el escalado, rotacin, traslacin y recortado.


Las regiones de clipping se definen por las mismas implementaciones de la
interface Shape que se usan para definir regiones generales de clipping, por
ejemplo Rectangle2D y GeneralPath.
Las composiciones de color se proporcionan por implementaciones de la interfaz
Composite, por ejemplo AlphaComposite. Un objeto Font se define como una
coleccin de Glyphs, que a su vez est definida por Shapes individuales.

31.1.2 Modelo de Renderizado
El mecanismo de renderizado bsico es el mismo que en las versiones anteriores
del JDK. El sistema de dibujo o renderizado controla cundo y cmo dibuja un
programa. Cuando un componente necesita ser mostrado, se llama
automticamente a su mtodo paint o update dentro del contexto Graphics
apropiado.
Como ya se mencion, el API 2D de Java presenta java.awt.Graphics2D, un nuevo
tipo de objeto Graphics. Graphics2D desciende de la clase Graphics para
roporcionar acceso a las caractersticas avanzadas de renderizado del API 2D de
Java.
Para usar las caractersticas del API 2D de Java, tenemos que forzar el objeto
Graphics pasado al mtodo de dibujo de un componente a un objeto Graphics2D.
Como se muestra en el siguiente cdigo:
public void Paint (Graphics g) {
Graphics2D g2 = (Graphics2D) g; ...
}
Al conjunto de atributos de estado asociados con un objeto Graphics2D se le
conoce como Contexto de Renderizado de Graphics2D. Para mostrar texto, formas
o imgenes, podemos configurar este contexto y luego llamar a uno de los mtodos
de renderizado de la clase Graphics2D, como draw o fill. Cmo muestra la
siguiente figura, el contexto de renderizado de Graphics2D contiene varios
atributos.

El estilo de lpiz que se aplica al exterior de una forma. Este atributo
stroke permite dibujar lneas con cualquier tamao de punto y patrn
de sombreado y aplicar finalizadores y decoraciones a la lnea.
Algunas aplicaciones de dibujo lo denominan filete.


El estilo de relleno que se aplica al interior de la forma. Este atributo
paint permite rellenar formas con colores slidos, gradientes o
patrones.

El estilo de composicin se utiliza cuando los objetos dibujados se
solapan con objetos existentes.

La transformacin que se aplica durante el dibujado para convertir el
objeto dibujado desde el espacio de usuario a las coordenadas de
espacio del dispositivo. Tambin se pueden aplicar otras
transformaciones opcionales como la traduccin, rotacin escalado,
recortado, a travs de este atributo.

El Clip que restringe el dibujado al rea dentro de los bordes de un
Shape se utiliza para definir el rea de recorte. Se puede usar
cualquier forma para definir un clip.

La fuente se usa para convertir cadenas de texto.

Punto de Renderizado que especifican las preferencias en cuanto a
velocidad y calidad. Por ejemplo, es posible especificar que se desea
usar antialiasing, si est disponible.
Para configurar un atributo en el contexto de renderizado de Graphics2D, se usan
los mtodos setAttribute.
setStroke
setPaint
setComposite
setTransform
setClip


setFont
setRenderingHints
Cuando se configura un atributo, se el pasa al objeto el atributo apropiado. Por
ejemplo, para cambiar el atributo paint a un relleno de gradiente azul-gris,
deberamos construir el objeto GradientPaint y luego llamar a setPaint.
gp = new GradientPaint(0f,0f,blue,0f,30f,green);
g2.setPaint(gp);

Graphics2D contiene referencias a sus objetos atributos, no son clonados. Si se
modifica un objeto atributo que forma parte del contexto Graphics2D, es necesario
llamar al mtodo set para notificarlo al contexto. La modificacin de un atributo de
un objeto durante el renderizado puede causar comportamientos impredecibles.

31.1.3 Mtodos de renderizado de Graphics2D
Graphics2D proporciona los siguientes mtodos generales de dibujado que pueden
usarse para dibujar cualquier primitivo geomtrico, texto o imagen.
draw Dibuja el exterior de una forma geomtrica primitiva usando los
atributos stroke y paint.
fill Dibuja cualquier forma geomtrica primitiva rellenado su interior
con el color o patrn especificado por el atributo paint.
drawString Dibuja cualquier cadena de texto. El atributo font se usa para
convertir la fuente a Glyphs que luego se rellenan con el color o
patrn especificados por el atributo paint.
drawImage Dibuja la imagen especificada.
Adems, Graphics2D soporta los mtodos de renderizado de Graphics para formas
particulares, como drawOval y fillRect.

Leccin 32 Ubicacin espacial, textos e imgenes
32.1 Sistema de coordenadas
El sistema 2D de Java mantiene dos sistemas de coordenadas:


El espacio de usuario es un sistema de coordenadas lgicas independiente
del dispositivo. Las aplicaciones usan este sistema de coordenadas
exclusivamente, y este es el espacio en el que se especifican los grficos
primitivos del Java 2D.
El espacio de dispositivo es el sistema de coordenadas para un dispositivo
especfico de salida, como una pantalla, una ventana o una impresora. En
un ambiente multi-ventana con un escritorio virtual donde una ventana
puede expandirse ms all de la pantalla del dispositivo fsico, este escritorio
virtual se adapta a todas las pantallas.

Aunque el sistema de coordenadas para una ventana o una pantalla podra ser
muy distinto que para una impresora, estas diferencias son invisibles para los
programas Java. Las conversiones necesarias entre el espacio de usuario y el
espacio de dispositivo se realizan automticamente durante el dibujado.

Espacio de usuario
Como se muestra en la Figura 55, el origen del espacio de usuario se localiza en la
esquina superior izquierda del espacio, con los valores de x incrementando a la
derecha y los valores de y incrementando hacia abajo.

Figura 55 Espacio de usuario

El espacio del usuario representa una abstraccin uniforme de todas los posibles
sistemas de coordenadas de dispositivos. El espacio de dispositivo para un
dispositivo particular podra tener el mismo origen y direccin del espacio del
usuario, o podran ser diferentes. Sin embargo, las coordenadas del espacio del
usuario son automticamente transformadas en las apropiadas para el espacio del


dispositivo cuando se dibuja un objeto grfico. Frecuentemente, la plataforma
subyacente o driver del dispositivo se utilizan para desarrollar esta conversin.

Espacio de dispositivo
El API 2D de Java define tres niveles de informacin de configuracin que se
mantienen para permitir la conversin desde un espacio de usuario a un espacio de
dispositivo. Esta informacin est encapsulada en tres clases:
GraphicsEnvironment
GraphicsDevice
GraphicsConfiguration
Entre ellas, representan toda la informacin necesaria para localizar un dispositivo
de renderizado o fuente en la plataforma Java y para convertir las coordenadas del
espacio de usuario al espacio de dispositivo. Una aplicacin puede tener acceso a
esta informacin, pero no necesita desarrollar modificaciones en ellas.
El GraphicsEnvironment describe la coleccin de dispositivos de renderizado
disponible para una aplicacin Java en un plataforma particular. Los dispositivos de
renderizado incluyen pantallas, impresoras y bferes de imagen. El
GraphicsEnvironment tambin incluye una lista de todas las fuentes disponibles en
una plataforma.
El GraphicsDevice describe un dispositivo de renderizado visible para la aplicacin,
tal como una pantalla o impresora. Cada configuracin posible de el dispositivo se
representa por una GraphicsConfiguration. Por ejemplo, un dispositivo de
visualizacin SVGA puede operara en varios modos: 640*480*16 colores,
640*480*256 colores y 800*600*256 colores. La pantalla SVGA est representada
por un objeto GraphicsDevice y cada uno de los modos es representado por un
objeto GraphicsConfiguration.
Un GraphicsEnvironment puede contener uno o ms GraphicsDevice, a su vez,
cada GraphicsDevice puede tener una o ms GraphicsConfiguration.

Transformaciones
El API Java 2D ha unificado su modelo de transformacin de coordenadas. Todas
las transformaciones de coordenadas, incluyendo transformaciones desde el
espacio del usuario al espacio del dispositivo, son representadas por objetos de la


clase AffineTransform, que define las reglas para manipular coordenadas usando
matrices.
Es posible adicionar un AffineTransform al contexto grfico para rotar, escalar,
trasladar o recortar una figura geomtrica, texto o imagen cuando se esta
renderizando. La transformacin adicional se aplica a cualquier objeto grfico
renderizado en ese contexto. La transformacin se realiza cuando el espacio de
coordenadas de usuario se convierte en espacio de coordenadas del dispositivo.

32.2 Fuentes
Una cadena se asume de manera normal, en trminos de los caracteres que la
conforman. Cuando se dibuja una cadena, su apariencia est determinada por la
letra o fuente que est seleccionada. Sin embargo, las figuras que la fuente usa
para mostrar la cadena no siempre corresponden con caracteres individuales, por
ejemplo, en publicidad profesional, ciertas combinaciones de dos o ms caracteres
se reemplazan a menudo por una figura simple denominada ligature.
Las figuras que una fuente usa para representar los caracteres en las cadenas se
denominan Glyphs. Una fuente puede representar un carcter como una a con
tlde usando varios glyphs, o representar ciertas combinaciones de caracteres
como la fi de final con un nico glyph. En el API Java 2D, una glyph es
simplemente un Shape que puede ser manipulado y dibujado en la misma forma
que cualquier otro objeto Shape.
Una fuente puede ser entendida como una coleccin glyphs. Una nica fuente
puede tener muchas versiones, tales como heavy, mdium, oblique, ghotic y
regular. Estas diferentes versiones son llamadas caras (faces). Todas las caras de
una fuente tienen un diseo tipogrfico similar y pueden ser reconocidas como
miembros de una misma familia. En otras palabras, una coleccin de glyphs con
una forma particular de estilo conforma una font face, una coleccin de formas de
font faces forman una font family, y una coleccin de font families conforma el
grupo de fuentes disponible en un GraphicsEnvironment particular.
En el API Java 2D, las fuentes se especifican por un nombre que describe una
particular font face (por ejemplo: Helvetica Bold) Es diferente a como se asume en
el JDK 1.1, en las que las fuentes eran descritas por nombres lgicos que tomaban
la forma de diferentes font face dependiendo de las fuentes disponibles en la
plataforma particular. Para lograr compatibilidad el API Java 2D soporta la
especificacin de fuentes por su nombre lgico y tambin por su nombre de font
face.


Usando el API 2D de Java es posible componer y dibujar cadenas que contienen
mltiples fuentes, de diferentes familias, caras, tamaos e incluso lenguajes. La
apariencia del texto est separada lgicamente de las caractersticas del texto. Los
objetos Font se utilizan para describir la apariencia, y la informacin de
caractersticas del texto se almacena en objetos TextLayout y TextAttibuteSet. Esta
posibilidad hace ms fcil de usar la misma fuente en texto con diferentes
caractersticas.

32.3 Imgenes
Las imgenes son colecciones de pxeles organizados espacialmente. Un pxel
define la apariencia de una imagen en una ubicacin simple. Un arreglo
bidimensional de pxeles se denomina una rster.
La apariencia del pxel puede definirse directamente o como un ndice en una tabla
de color para una imagen. En imgenes que contienen muchos colores (ms de
256), los pxeles usualmente representan directamente el color, alpha y otras
caractersticas de cada localizacin de la pantalla. Tales imgenes tienden a ser
muchos ms grandes que las imgenes de color indexado (indexed-color
images), pero ellas son ms realistas.
En una imagen de color indexado, los colores en la imagen estn limitados a los
colores especificados en una tabla de colores, a menudo, el resultado es que slo
es posible usar unos pocos colores en la imagen. Sin embargo, un ndice requiere
menos almacenamiento que un valor de color, por tanto el resultado es que las
imgenes de colores indexados son ms pequeas. El formato de pxel es popular
para las imgenes que contienen slo 16 o 256 colores.
Las imgenes en el API 2D de java tiene dos componentes primarios:
Los datos de la imagen original (los pxeles)
La informacin necesaria para interpretar los pxeles.
Las reglas para interpretar los pxeles estn encapsuladas en un objeto
ColorModel (por ejemplo, los valores podran ser interpretados de dos formas,
como colores directos o indexados). Para que un pxel pueda ser mostrado, debe
estar relacionado con un modelo de color.
Una banda o canal (band) es un componente del espacio de color de una imagen.
Por ejemplo, el Rojo (Red), Verde (Green)y Azul (Blue) son las bandas o canales
de una imagen RGB. Un pxel en una imagen de modelo de color directo puede


tomarse de una coleccin de valores de las bandas para una localizacin en la
pantalla.
El paquete java.awt.image contiene la implementacin de varios ColorModel,
incluyendo representaciones de pixeles empaquetados o comprimidos y de
componente.
Una objeto ColorSpace encapsula las reglas que gobiernan la forma como un
conjunto de valores numricos corresponden a un color particular. La
implementacin del ColorSpace en el java.awt.color representa los espacios de
color ms popular, incluyendo RGB y escala de grises. Es importante aclarar que
un espacio de color no es una coleccin de colores, el define las reglas como
debern ser interpretados los valores de colores individuales.
Al separar el espacio de color (ColorSpace) del modelo de color (ColorModel) se
proporciona mayor flexibilidad para representar y convertir de una representacin
de color a otra.

Leccin 33 Rellenos, Filetes y Composiciones
33.1 Rellenos y Filetes
Como ya se haba mencionado, con el API 2D de Java es posible usar diferentes
estilos de lpices (filetes) y patrones de relleno. Como el texto est en ltimas
representado por un conjunto de glyphs, a las cadenas de texto tambin se les
puede aplicar atributos de filete y relleno.

Figura 56 Dibujo con diferentes tipos de filete
Los estilos de lpices estn definidos
por objetos que implementan la
interfaz Stroke. El filete hace posible
especificar diferentes anchos y
patrones de diseo para lneas y
curvas.

Los patrones de rellenos estn definidos por objetos que implementan la interfaz
Paint. La clase Color, que est disponible en versiones anteriores de AWT, es un
tipo simple de un objeto Saint usado para definir rellenos de colores slidos. El API
2D de Java proporciona dos implementaciones adicionales para Paint,
TexturePaint y GradientPaint.


El TexturePaint define un patrn
de relleno utilizando un simple
fragmento de imagen que se repite
uniformemente. El GradientPaint
define un relleno como un
gradiente entre dos colores.

Figura 57 Relleno de gradiente y de textura

En Java 2D, el renderizado de la lnea exterior y el relleno de una figura son dos
operaciones separadas:
Usando el mtodo draw se dibuja el contorno (lnea exterior) de la figura usando el
estilo de lpiz especificado en el atributo Stroke y el patrn de relleno especificado
por el atributo Paint.
Usado el mtodo fill se rellena el interior de la figura con el patrn especificado en
el atributo Paint.
Cuando se renderiza una cadena de texto, el atributo actual de Paint se aplica a los
glyphs que forman la cadena. Sin embargo, drawString actualmente rellena los
glyphs que estn siendo renderizados. Para modificar el filete del contorno de los
glyphs en una cadena de texto, es necesario enviar el contorno y renderizarlos
como figuras usando el mtodo draw.

33.2 Composiciones (composites)
Cuando se renderiza un objeto que se sobrepone con otro objeto existente, es
necesario determinar como se deben combinar los colores del nuevo objeto von los
colores que ya estn ocupando el rea donde se est dibujando. El API 2D de Java
encapsula reglas para combinar los colores en el objeto Composite.
Los sistemas de renderizado primitivo proporcionan solamente operadores
bolanos bsicos para combinar los colores. Por ejemplo, una regla de
composicin booleana puede definir los valores de color de la fuente y el destino a
partir de operaciones de And, OR y XOR. Este enfoque tiene varios inconvenientes,
como lo poco intuitivo para el ser humano, adems que este tipo de composiciones
no permite la composicin de colores en diferentes espacios de color, adems de
no considerar el caso de las imgenes de color indexado, ya que el resultado de la


operacin booleana de dos valores de pxel en una imagen es la composicin de
dos ndices, no de dos colores.
El API 2D de Java evita estos inconvenientes al implementar reglas de mezcla alfa
(alpha-blending) que tienen en cuenta la informacin acerca del modelo de color al
hacer las composiciones. El objeto alphaComposite incluye el modelo del color de
los colores fuente y destino.

Leccin 34 Los paquetes del API 2D de Java
Las clases del API Java 2D est organizada en los siguientes paquetes:
java.awt
java.awt.geom
java.awt.font
java.awt.color
java.awt.image java.awt.image.renderable
java.awt.print
El paquete java.awt contiene algunas clases e interfaces del API Java 2D,
obviamente no todas las clases del java.awt son clases del Java 2D.
AlphaComposite BasicStroke Color
Composite CompositeContext Font
GradientPaint Graphics2D GraphicsConfiguration
GraphicsDevice GraphicsEnvironment Paint
PaintContext Rectangle Shape
Stroke TexturePaint Transparency

El paquete java.awt.geom contiene clases e interfaces relacionadas con la
definicin de primitivas geomtricas.
AffineTransform Arc2D Arc2D.Double


Arc2D.Float Area CubicCurve2D
CubicCurve2D.Double CubicCurve2D.Float Dimension2D
Ellipse2D Ellipse2D.Double Ellipse2D.Float
FlatteningPathIterator GeneralPath Line2D
Line2D.Double Line2D.Flota PathIterator
Point2D Point2D.Double Point2D.Float
QuadCurve2D QuadCurve2D.Double QuadCurve2D.Float
Rectangle2D Rectangle2D.Double Rectangle2D.Float
RectangularShape RoundRectangle2D RoundRectangle2D.Double
RoundRectangle2D.Float
Muchas de las primitivas geomtricas tienen sus correspondientes
implementaciones .Float y .Double. Las implementaciones de doble precisin
proporcionan mayor precisin de renderizado, pero a expensas del desempeo en
algunas plataformas.
El paquete java.awt.font contiene clases e interfaces que se utilizan para
proporcionar caractersticas al texto y la definicin de fuentes.
FontRenderContext GlyphJustificationInfo GlyphMetrics
GlyphVector GraphicAttribute ImageGraphicAttribute
LineBreakMeasurer LineMetrics MultipleMaster
OpenType ShapeGrapicAttribute TextAttribute
TextHitInfo TextLayout TransformAttribute

El paquete java.awt.color contiene clases e interfaces para la definicin de
espacios de color y perfiles de color.
ColorSpace ICC_ColorSpace ICC_Profile
ICC_ProfileGray ICC_ProfileRGB


Los paquetes java.awt.image y java.awt.image.renderable contienen clases e
interfaces para la definicin y renderizado de imgenes.
AffineTransformOp BandCombineOp BandedSampleModel
BufferedImage BufferedImageFilter BufferedImageOp
ByteLookupTable ColorConvertOp ColorModel
ComponentColorModel ComponentSampleModel ConvolveOp
ContextualRenderedImageFactory DataBuffer
DataBufferByte DataBufferInt DataBufferShort
DataBufferUShort DirectColorModel IndexColorModel
Kernel LookupOp LookupTable
MultiPixelPackedSampleModel PackedColorModel
ParameterBlock PixelInterleavedSampleModel Rster
RasterOp RenderableImage RenderableImageOp
RenderContext RenderableImageProducer RenderedImageFactory
RenderedImage RescaleOp SampleModel
ShortLookupTable TileObserver WritableRaster
WritableRenderedImage SinglePixelPackedSampleModel

El API Java 2D mejora las siguientes clases heredadas de la clase image de AWT
ColorModel
DirectColorModel
IndexColorModel
Estas clases de modelo de color recogen las caractersticas del java.awt.image
para compatibilidad, y para mantener consistencia, las nuevas clases del modelo
de color tambin estn localizadas en el paquete java.awt.image.


El paquete java.awt.print contiene clases e interfaces que hacen posible la
impresin de todos los objetos grficos basados en Java 2D, como texto, grficos e
imgenes.
Book Pageable PageFormat
Paper Printable PrinterGraphics
PrinterJob
Antes de comenzar en serio con los componentes grficos que proporciona el API
2D de java, es necesario, hacer una pequea revisin de la clase Graphics,
superclase de Graphics2D y revisar algunos conceptos bsicos acerca del contexto
grfico, que posteriormente permitirn comprender mucho mejor los ejemplos que
se presentarn.

Leccin 35 La clase Graphics
La clase Graphics es la clase base abstracta que proporciona toda, o al menos la
mayora, de la funcionalidad para poder pintar tanto sobre componentes como
sobre imgenes fuera de pantalla.
Un objeto Graphics encapsula la siguiente informacin que ser necesaria a la hora
de las operaciones bsicas de pintado.
El objeto de tipo Component sobre el que se pinta
Un origen de traslacin para coordenadas de pintado y clipping
La regin actual ocupada por el componente
El color actual
La fuente de caracteres actual
La operacin lgica actual para utilizar con pixeles (XOR o Paint)
La actual alteracin de color XOR
Un objeto Graphics describe un contexto grfico. Un contexto grfico define una
zona de recorte, una zona a la que va a afectar; cualquier operacin grfica que se
realice modificar solamente los pixeles que se encuentren dentro de los lmites de
la zona de recorte actual y el componente que fue utilizado para crear el objeto
Graphics.


Cuando se pinta o escribe, ese dibujo o escritura se realiza en el color actual,
utilizando el modo de dibujo actual y la fuente de caracteres actual.
Hay muchas otras clases, como la clase Rectangle y la clase Polygon, que utilizan
como soporte a las operaciones que se pueden realizar con la clase Graphics.
Para poder revisar esta clase, quiz una de las mejores formas sea a travs de sus
mltiples mtodos, intentando agruparlos por funcionalidad, que es lo que se ha
intentado aqu, aunque si el lector quiere una referencia completa y una descripcin
de los mtodos de esta clase deber recurrir a la documentacin que JavaSoft
proporciona sobre el AWT.
Hay que empezar hablando del constructor de la clase Graphics, que no tiene
argumentos; aunque Graphics es una clase abstracta, por lo que las aplicaciones
no pueden llamar a este constructor directamente. Se puede obtener un objeto de
tipo Graphics a partir de otro objeto Graphics llamando al mtodo getGraphics()
sobre un componente. Tambin se puede recibir un objeto Graphics como
parmetro cuando se van a sobreescribir los mtodos paint() o update().

35.1 Mtodos generales de la clase Graphics
En esta categora estaran incluidos los mtodos tiles en general, sin una
asignacin especfica de funcionalidad con respecto a acciones determinadas de
dibujo. A continuacin se enumeran algunos de los mtodos considerados
generales, para seguir con la descripcin y uso de algunos de ellos en aplicaciones
de ejemplo.
clearRect( int,int,int,int ), se le pasa un rectngulo y borra la zona con el color que
se haya establecido de fondo para la superficie donde se est pintando.
copyArea( int,int,int,int,int,int ), copia la zona rectangular del componente que se
indica en los primeros cuatro parmetros, en otra posicin del contexto grfico
desplazada las distancia indicada en los dos ltimos parmetros.
create(), crea un nuevo objeto de tipo Graphics que es copia del objeto Graphics
que ha invocado al mtodo.
dispose(), elimina el contexto grfico sobre el cual es invocado y devuelve al
sistema todos los recursos que estaba utilizando, incluyendo todos los recursos, no
solamente la memoria. Un objeto Graphics no se puede utilizar despus de haber
llamado a este mtodo; y es importante que se eliminen estos objetos
manualmente, bien sea creados directamente desde un componente o a partir de


otro objeto Graphics, cuando ya no se necesiten, en lugar de esperar a que se
finalice la ejecucin.
finalice(), elimina el contexto grfico cuando ya no hay ninguna referencia sobre l.
getColor(), devuelve el color actual fijado para el contexto grfico.
setColor( Color ), fija el color del contexto grfico al color que se pasa como
parmetro. Todas las operaciones grfica siguientes que utilicen este contexto
grfico, utilizarn el color que se especifica en este mtodo.
setPaintMode(), fija la forma de pintar del contexto grfico de modo que se
sustituya lo que haba con lo nuevo. Cualquier operacin de pintado sobreescribir
lo que hubiese en la zona de destino con el color actual.
setXORMode( Color ), fija la forma de pintar del contexto grfico a una alternancia
entre en color actual y el color de la zona de destino.
toString(), devuelve un objeto de tipo String representando el valor del objeto
Graphics.
translate( int,int ), traslada el origen del contexto grfico al punto que se pasa en
los dos parmetros en el sistema de coordenadas que se est utilizando.

35.2 Obtener un contexto grfico
La verdad es que se han escrito varias veces las palabras contexto grfico, y no se
ha proporcionado al lector una explicacin concreta de lo que significan estos
trminos. Hay varias definiciones, para unos significa que la aplicacin ha
conseguido la habilidad para pintar o colocar imgenes sobre un componente que
tiene la caracterstica de soportar el pintado o visualizacin de imgenes. Otros
autores prefieren decir que cada objeto Graphics representa una determinada
superficie de dibujo, luego ese objeto Graphics define un contexto grfico a travs
del cual se pueden manipular todas las actividades grficas sobre esa superficie. Y
otros autores indican que un objeto Graphics es la superficie ltima sobre la que se
pueden colocar lneas, figuras y texto, por lo cual puede recibir tambin el nombre
de contexto grfico al aunar informacin sobre la zona de dibujo, ms la fuente de
caracteres, color y cualquier otro factor.
Ahora que ya se sabe lo que es un contexto grfico, hay que ver cmo se consigue
crear uno. Para empezar, esto no puede hacerse instanciando directamente un
objeto de tipo Graphics, ya que la clase Graphics es abstracta y no puede ser


instanciada por el cdigo de la aplicacin, as que hay que recurrir a formas
indirectas para conseguir el contexto grfico.
Uno de estos caminos indirectos para obtener un contexto grfico es invocar el
mtodo getGraphics() sobre otro objeto. Sin embargo, este mtodo devuelve un
contexto grfico de una imagen, es decir, que solamente funciona para objetos de
tipo Image creados en memoria a travs del mtodo createImage(), de la clase
Component. Esta es una tcnica utilizada normalmente cuando se estn usando
imgenes que se crean en memoria y luego se transfieren a la pantalla, es decir, se
est pintando en el doble buffer.
Hay otros dos caminos para obtener un contexto grfico y, son sorprendentemente
simples, porque se hace automticamente, y es cuando se sobreescriben los
mtodos paint() y update(), en los cuales Java pasa como parmetro el contexto
grfico del objeto al que pertenece el mtodo.
Normalmente, el mtodo paint() se sobreescribe cuando se quiere colocar algn
tipo de material grfico sobre la pantalla, y el mtodo update() se sobreescribe en
circunstancias especiales, como puede ser el caso de una animacin o que se vaya
a utilizar doble buffer. Lo normal es pues la presentacin de informacin grfica
colocando el cdigo encargado de ello en el mtodo sobreescrito paint() y luego
invocando al mtodo repaint() para indicar al sistema que presente ese material en
pantalla; aunque el mtodo paint() tambin puede ser invocado por causas
externas, sin control alguno por parte de la aplicacin, como puede ser el
redimensionamiento de la ventana en la que se est presentando la informacin
grfica.
Hay que tener en cuenta que el mtodo repaint() pide al sistema que redibuje el
componente tan pronto como sea posible, pero esto lo har el mtodo update() que
se llame a continuacin. No hay una relacin uno a uno entre las llamadas a
repaint() y update(), por lo que es posible que mltiples llamadas a repaint() puedan
recogerse en una sola llamada a update().
El mtodo update() es invocado automticamente cuando se pide repintar un
Componente. Si el componente no es ligero (lightweight), la implementacin por
defecto de update() borra el contexto grfico rellenando el fondo en el color que se
haya asignado como color de fondo, fijando de nuevo el color al color del primer
plano y llamando a paint(). Si no se sobreescribe update() para hacer una
animacin, se ver siempre un parpadeo en el refresco del componente por causa
de este borrado del fondo.


En sntesis, el mtodo paint() es el que ofrece el sistema para poder pintar lo que
se quiera sobre un determinado componente. En la clase base Component, este
mtodo no hace absolutamente nada. Normalmente, en el caso de applets, se
sobreescribe para hacer presentar un rectngulo relleno con el color de fondo.
Veamos un primer ejemplo bsico de obtencin del contexto grfico y pintado de
una cadena de texto en un objeto Frame en la Figura 58. Notar que se utiliza la
clase Frame del AWT y no la JFrame del Swing, ya que se quieren asegurar la
compatibilidad.

Figura 58 Primer ejemplo de dibujo utilizando Java 2D
Observe que en la lnea 36 se est convirtiendo el contexto grfico original g en un
contexto grfico 2D denominado g2, que es el que finalmente se utiliza para dibujar
la cadena.

CAPTULO 8 API 3D de JAVA
Leccin 36 Figuras bsicas en Java 2D (Shape)
Las clases del paquete java.awt.geom definen grficos primitivos comunes, como
puntos, lneas, curvas, arcos, rectngulos y elipses.
Las clases en el paquete java.awt.geom son:
Arc2D Ellipse2D QuadCurve2D


Area GeneralPath Rectangle2D
CubicCurve2D Line2D RectangularShape
Dimension2D Point2D RoundRectangle2D
Excepto para Point2D y Dimension2D, cada una de las otras clases geomtricas
implementa el interfaz Shape, que proporciona un conjunto de mtodos comunes
para describir e inspeccionar objetos geomtricos bi-dimensionales.
Con estas clases podemos crear de forma virtual cualquier forma geomtrica y
dibujarla a travs de Graphics2D llamando al mtodo draw o al mtodo fill.

36.1 Formas Rectangulares
Los primitivos Rectangle2D, RoundRectangle2D, Arc2D, y Ellipse2D descienden de
la clase RectangularShape, que define mtodos para objetos Shape que pueden
ser descritos por una caja rectangular. La geometra de un RectangularShape
puede ser extrapolada desde un rectngulo que encierra completamente el exterior
de la forma, como se muestra en la siguiente figura.

Figura 59 Formas rectangulares

36.2 GeneralPath
La clase GeneralPath permite crear una curva arbitraria especificando una serie de
posiciones a lo largo de los lmites de la forma.

Figura 60 Forma GeneralPath
Estas posiciones pueden ser conectadas por
segmentos de lnea, curvas cuadrticas o curvas
cbicas.
Esta figura puede ser creada con 3 segmentos de
lnea y una curva cbica.


El siguiente ejemplo muestra el uso de algunos de estos objetos grficos y adems
de las opciones para relleno y filete. El cdigo original corresponde en un demo
proporcionado en el tutorial de Java 2D de la documentacin del J2SE.

Figura 61 Ejecucin del renderizado de figuras primitivas
El cdigo comentado se muestra a continuacin. Como se dar cuenta es bastante
extenso, por lo que se recomienda seguirlo cuidadosamente. Una vez lo ha
implementado y comprendido, intente realizar modificaciones en los parmetros de
dibujo de las diferentes figuras.
/*
* Este es un ejemplo sobre el dibujo de Shapes, proporcionado por la
* documentacin de Java en la versin 1.2.
*/

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;

/*
* La clase se crea como hija de la clase Applet. Si se define como hija


* directa de la clase Frame, se tiene problemas al redimensionar el
* Frame, ya que no se redibujan automticamente las figuras.
*/

public class ShapesDemo2D extends JApplet {
final static int maxCharHeight = 15;
final static int minFontSize = 6;

final static Color bg = Color.white;
final static Color fg = Color.black;
final static Color red = Color.red;
final static Color white = Color.white;

//Definicin de los tipos de filete
final static BasicStroke stroke = new BasicStroke(2.0f);
final static BasicStroke wideStroke = new BasicStroke(8.0f);

final static float dash1[] = {10.0f};
final static BasicStroke dashed = new BasicStroke(1.0f,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f, dash1, 0.0f);
Dimension totalSize;
FontMetrics fontMetrics;

public void init() {
//Initialize drawing colors
setBackground(bg);
setForeground(fg);
}

/* Permite redimensionar el tamao de la letra a partir de un objeto de tipo Fontmetrics
* dependiendo del tamao del contexto grfico, si se ampla el tamao de la ventana, la
* letra se ampliar, si se disminuye el tamao del contexto la letra disminuir
*/
FontMetrics pickFont(Graphics2D g2,
String longString,


int xSpace) {
boolean fontFits = false;
Font font = g2.getFont();
FontMetrics fontMetrics = g2.getFontMetrics();
int size = font.getSize();
String name = font.getName();
int style = font.getStyle();

while ( !fontFits ) {
if ( (fontMetrics.getHeight() <= maxCharHeight)
&& (fontMetrics.stringWidth(longString) <= xSpace) ) {
fontFits = true;
}
else {
if ( size <= minFontSize ) {
fontFits = true;
}
else {
g2.setFont(font = new Font(name,
style,
--size));
fontMetrics = g2.getFontMetrics();
}
}
}

return fontMetrics;
}

public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);

/* Toma las dimensiones del contexto y lo divide para saber el ancho y alto de
* cada una de las celdas de la cuadrcula donde dibujar
*/


Dimension d = getSize();
int gridWidth = d.width / 6;
int gridHeight = d.height / 2;

//Obtiene el tamao de la letra a partir de la cadena ms larga a escribir
fontMetrics = pickFont(g2, "GeneralPath con relleno y contorno",
gridWidth);

//Dibuja el cuadrado general que sirve de fondo al applet
Color fg3D = Color.lightGray;
g2.setPaint(fg3D);
g2.draw3DRect(0, 0, d.width - 1, d.height - 1, true);
g2.draw3DRect(3, 3, d.width - 7, d.height - 7, false);
g2.setPaint(fg);

int x = 5;
int y = 7;
int rectWidth = gridWidth - 2*x;
int stringY = gridHeight - 3 - fontMetrics.getDescent();
int rectHeight = stringY - fontMetrics.getMaxAscent() - y - 2;

// Dibuja una lnea con su respectivo texto inferior
g2.draw(new Line2D.Double(x, y+rectHeight-1, x + rectWidth, y));
g2.drawString("Line2D", x, stringY);
x += gridWidth;

// Asigna un filete, dibuja el rectngulo y debajo su respectivo texto
g2.setStroke(stroke);
g2.draw(new Rectangle2D.Double(x+5, y+5, rectWidth-5, rectHeight-5));
g2.drawString("Rectangle 2D", x, stringY);
x += gridWidth;

/* Asigna el filete como punteado, dibuja un rectngulo con
* bordes redondeados y su texto inferior
* Los parmetros de creacin del objeto correspoden al valor en x e y inicial
* x e y final y el radio de la circunferencia que define las puntas redondeadas.


*/
g2.setStroke(dashed);
g2.draw(new RoundRectangle2D.Double(x+20, y+20, rectWidth-40,
rectHeight-40, 40, 40));
g2.drawString("RoundRectangle2D", x, stringY);
x += gridWidth;

/* Asigna el filete, dibuja un arco con 7 parmetros de construccin.
* Ellos son: el rectngulo que enmarca el arco tiene esquina superior izquierda en
* en x,y,el valor mximo en x, el valor mximo en y. Los siguientes dos parmetros
* corresponde a los ngulos de inicio y fin del arco, en este caso 60 y 135 grados.
* Finalmente el ltimo parmetro corresponde al tipo de arco, los posibles valores son
* OPEN, CHORD, PIE.
* Debajo escribe el texto correspondiente
*/
g2.setStroke(wideStroke);
g2.draw(new Arc2D.Double(x, y, rectWidth, rectHeight, 60, 135, Arc2D.OPEN));
g2.drawString("Arc2D", x, stringY);
x += gridWidth;

// Asigna el filete, dibuja una elipse y el texto inferior correspondiente g2.setStroke(stroke);
g2.draw(new Ellipse2D.Double(x, y, rectWidth, rectHeight));
g2.drawString("Ellipse2D", x, stringY);
x += gridWidth;

/* Asigna el filete, crea unos vectores con las coordenadas de los puntos del polgono,
* crea el objeto GeneralPath (polygon) trazando lineas entre las coordenadas
* y finalmente cierra el poligono. Dibuja el polgono y el texto inferior
* correspondiente.
*/
g2.setStroke(stroke);
int x1Points[] = {x, x+rectWidth, x, x+rectWidth};
int y1Points[] = {y, y+rectHeight, y+rectHeight, y};
GeneralPath polygon = new GeneralPath(GeneralPath.WIND_EVEN_ODD, x1Points.length);
polygon.moveTo(x1Points[0], y1Points[0]);
for ( int index = 1; index < x1Points.length; index++ ) {
polygon.lineTo(x1Points[index], y1Points[index]);


};
polygon.closePath();
g2.draw(polygon);
g2.drawString("GeneralPath", x, stringY);

// Modifica los valores de coordenadas x e y para dibujar la segunda fila
x = 5;
y += gridHeight;
stringY += gridHeight;

/* Realiza los mismo pasos que para el polgono anterior, lo que vara es
* que en este caso no se cierra el polgono
*/
GeneralPath polyline = new GeneralPath(GeneralPath.WIND_EVEN_ODD, x2Points.length);
polyline.moveTo (x2Points[0], y2Points[0]);
polyline.lineTo(x2Points[index], y2Points[index]);
};
g2.draw(polyline);
g2.drawString("GeneralPath (Abierto)", x, stringY);
x += gridWidth;

/* Asigna el color de relleno a azul. Rellena un objeto rectngulo y lo dibuja. Nuevamente
* asigna el color, en este caso al negro y dibuja el texto inferior correspondiente
*/
g2.setPaint(Color.blue);
g2.fill(new Rectangle2D.Double(x, y, rectWidth, rectHeight));
g2.setPaint(fg);
g2.drawString("Rectangle2D con relleno", x, stringY);
x += gridWidth;

/* Define el objeto gradiente para rellenar el rectngulo redondeado, partiendo
* del color rojo hasta el color amarillo. Ese objeto GradientPaint se enva como
* color de relleno mediante el setPaint. Se dibuja el rectngulo redondeado.
* Se restaura el color de dibujo al negro y se dibuja el texto inferior.


*/
GradientPaint relleno = new GradientPaint(x,y,red,x+rectWidth, y,Color.yellow);
g2.setPaint(relleno);
g2.fill(new RoundRectangle2D.Double(x, y, rectWidth,
rectHeight, 10, 10));
g2.setPaint(fg);
g2.drawString("RoundRectangle2D con gradiente", x, stringY);
x += gridWidth;

// Define el color de relleno en rojo y dibuja el arco.
g2.setPaint(red);
g2.fill(new Arc2D.Double(x, y, rectWidth, rectHeight, 90, 135, Arc2D.PIE));
g2.setPaint(fg);
g2.drawString("Arc2D con relleno", x, stringY);
x += gridWidth;

// Define un relleno de gradiente de rojo a blanco y dibuja la elipse rellena.
relleno = new GradientPaint(x,y,red,x+rectWidth, y,white);
g2.setPaint(relleno);
g2.fill (new Ellipse2D.Double(x, y, rectWidth, rectHeight));
g2.setPaint(fg);
g2.drawString("Ellipse2D con gradiente", x, stringY);
x += gridWidth;

/* Define los arreglos de las coordenadas para el polgono. Crea el polgono uniendo
* los puntos con lneas. Asigna el color rojo y dibuja el polgono relleno.
* Retorna el valor de la pintura a negro y dibuja el polgono mediante draw, lo
* que origina que se sibuje el filete del polgono.
*/
GeneralPath filledPolygon = new GeneralPath(GeneralPath.WIND_EVEN_ODD,
x3Points.length);
filledPolygon.moveTo(x3Points[0], y3Points[0]);
filledPolygon.lineTo(x3Points[index], y3Points[index]);
};


filledPolygon.closePath();
g2.setPaint(Color.yellow);
g2.fill(filledPolygon);
g2.setPaint(fg);
g2.setStroke(wideStroke);
g2.draw(filledPolygon);
g2.drawString("GeneralPath con relleno y contorno", x, stringY);
}

//Clase que se ejecuta
public static void main(String s[]) {
//Crea el Frame
JFrame f = new JFrame("Demo de Figuras Primitivas");
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {System.exit(0);}
});
//Crea el applet de acuerdo a la clase ShapesDemo2D
JApplet applet = new ShapesDemo2D();
//Agrega el objeto applet al Frame
f.getContentPane().add("Center", applet);
applet.init();
f.pack();
f.setSize(new Dimension(550,300));
f.show();
}
}

36.3 QuadCurve2D y CubicCurve2D
La clase QuadCurve2D permite crear segmentos de curvas cuadrticos. Una curva
cuadrtica est definida por dos puntos finales y un punto de control.
La clase CubicCurve2D permite crear segmentos de curvas cbicos. Una curva
cbica est definida por dos puntos finales y dos puntos de control, los segmentos
de curvas cbicos tambin se conocen como curvas de Bzier. Las siguientes
figuras muestran ejemplos de curvas cuadrticas y cbicas.


Figura 62 Formas Curvas
El siguiente cdigo crea una curva cuadrtica con dos puntos finales y un punto de
control. Las posiciones de los puntos se seleccionan con respecto al tamao de la
ventana.
import java.awt.*;

public class EjemploQuad extends JApplet {

setBackground(Color.white);
setForeground(Color.black);
}


int w = d.width;
int h = d.height;

//Crea el objeto de tipo QuadCurve2D
QuadCurve2D.Double quad = new QuadCurve2D.Double();


//Crea los objetos que definen los puntos de inicio, final y control
Point2D.Double inicio, fin, control;
inicio = new Point2D.Double();
fin = new Point2D.Double();
control = new Point2D.Double();

//Le asigna coordenadas a los puntos en x e y a partir del tamao de la ventana
inicio.setLocation(w/2-100, h/2+50);
fin.setLocation(w/2+100, h/2+50);
control.setLocation((int)(inicio.x)+100, (int)(inicio.y)-100);

quad.setCurve(inicio, control, fin); //Construye la curva

//Define color y filete
g2.setPaint(Color.magenta);
g2.setStroke(new BasicStroke(2.0f));

//Dibuja la curva
g2.draw(quad);

//Modifica el color para dibujar los puntos como rectngulos
g2.setPaint(Color.black);
g2.fill(new Rectangle2D.Double(inicio.x, inicio.y,3,3));
g2.drawString("Inicio", (int) inicio.x+5,(int) inicio.y+5);
g2.fill(new Rectangle2D.Double(fin.x, fin.y,3,3));
g2.drawString("Fin",(int) fin.x+5, (int)fin.y+5);
g2.fill(new Rectangle2D.Double(control.x, control.y,3,3));
g2.drawString("Control",(int)control.x+5, (int)control.y+5);
}
//Clase que se ejecuta

//Crea el Frame
JFrame f = new JFrame("Dibujando un QuadCurve2D");
});


//Crea el applet de acuerdo a la clase ShapesDemo2D
JApplet applet = new EjemploQuad();
//Agrega el objeto applet al Frame
applet.init();
f.pack();
f.show();
}
}

La ejecucin de este cdigo proporciona la siguiente ventana grfica:

Figura 63 Ejecucin del dibujo de una curva
cuadrtica
Intente implementar una aplicacin
que dibuje una curva cbica, dibuje
tambin los puntos de referencia para
la curva, mediante rectngulos
rellenos. Aplique diferentes tipos de
filete, a partir de lo ya visto.

Leccin 37 reas
Con la clase Area se pueden realizar operaciones boolenas, como uniones,
intersecciones y substracciones, sobre dos objetos Shape cualquiera. Esta tcnica,
permite crear rpidamente objetos Shape complejos sin tener que describir cada
lnea de segmento o cada curva, este proceso se denomina construir un rea
geomtrica (CAG). Una Area soporta las siguientes operaciones booleanas.


unin

Sustraccin

Interseccin

Or-Exclusivo
(XOR)

En el siguiente ejemplo, tomado del tutorial de grficos del sitio web de
Programacin en castellano, se crea un Area que dibuja una pera a partir de
objetos elipses y operaciones de unin, sustraccin e interseccin. La ejecucin
proporciona la siguiente ventana grfica.

Figura 64 Formacin de una pera a partir de operaciones de rea
El cdigo que se requiere para el renderizado de este grfico se presenta a
continuacin.
import java.awt.*;
import java.awt.font.*;
import java.applet.*;

/*
* Este applet dibuja una pera, usando mtodos de Constructive Area Geometry (CSG)


* para adicin, sustraccin e interseccin.
*/

public class Pera extends Applet {

Ellipse2D.Double circle, oval, leaf, stem;
Area circ, ov, leaf1, leaf2, st1, st2;

circle = new Ellipse2D.Double();
oval = new Ellipse2D.Double();
leaf = new Ellipse2D.Double();
stem = new Ellipse2D.Double();
circ = new Area(circle);
ov = new Area(oval);
leaf1 = new Area(leaf);
st1 = new Area(stem);

}

public void paint (Graphics g) {

//Toma las dimensiones del contexto grfico, en este caso el Frame
int w = d.width;
int h = d.height;
double ew = w/2;
double eh = h/2;

g2.setColor(Color.green);

/* Crea la primera hoja a partir de la interseccin de dos objetos Area, creados
* a partir de una elipse


*/
leaf.setFrame(ew-16, eh-29, 15.0, 15.0);
leaf.setFrame(ew-14, eh-47, 30.0, 30.0);
leaf1.intersect(leaf2);
g2.fill(leaf1);

// Crea la segund hoja.
leaf.setFrame(ew+1, eh-29, 15.0, 15.0);
leaf2.intersect(leaf1);
g2.fill(leaf2);

g2.setColor(Color.black);

/* Crea el pedazo de tronco a partir del llenado del Area resultante de la sustraccin de
* dos objetos Area creados a partir de una elipse.
*/
stem.setFrame(ew, eh-42, 40.0, 40.0);
stem.setFrame(ew+3, eh-47, 50.0, 50.0);
st1.subtract(st2);
g2.fill(st1);

g2.setColor(Color.yellow);

/* Crea el cuerpo de la pera llenado el Area resultante de la unin de dos objetos
* Area, creados de una elipse un circulo.
*/
circle.setFrame(ew-25, eh, 50.0, 50.0);
oval.setFrame(ew-19, eh-20, 40.0, 70.0);
circ = new Area(circle);
ov = new Area(oval);
circ.add(ov);
g2.fill(circ);


}
JFrame f = new JFrame("Pera");
});
Applet applet = new Pera();
applet.init();
f.pack();
f.show();
}
}

Leccin 38 Texto y Fuentes
Es posible mostrar una cadena de texto con cualquier tipo de letra disponible en el
sistema, en cualquier tamao y en el estilo que se seleccione. Para determinar las
fuentes que estn disponibles en el sistema es necesario llamar el mtodo
GrpahicsEnvironment.getAvailableFontFamilyNames. Este mtodo retorna un
arreglo de cadenas que contiene los nombres de las familias de las fuentes
disponibles, cualquiera de estas cadenas, adems del tamao y el estilo, pueden
ser utilizados como argumentos para crear un nuevo objeto Font.

Figura 65 Ejemplo de dibujo de fuentes
El siguiente ejemplo, muestra
una aplicacin donde es
posible seleccionar el tipo de
fuente, tamao y estilo a partir
de 3 objetos combo y observar
las modificaciones en la
cadena dibujada. El ejemplo
es tomado del Tutorial de Java
2D de Sun Microsystems. La
ejecucin del programa genera
una pantalla como la que se
muestra al lado.


Para construir el ejemplo, es necesario utilizar el siguiente cdigo que permite
obtener los datos de las fuentes instaladas en el sistema y guardarlos en un objeto
Vector, que posteriormente puede pasarse a un combo que despliegue los
nombres de las fuentes:
GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();
String envcmbFuente[] = gEnv.getAvailableFontFamilyNames();
Vector vector = new Vector();
for ( int i = 1; i < envcmbFuente.length; i++ ) {
vector.addElement(envcmbFuente[i]);
}
cmbFuente = new JComboBox( vector );
cmbFuente.setMaximumRowCount( 9 );
cmbFuente.addItemListener(this);
nuevafuente = envcmbFuente[0];
pnlLetra.add(cmbFuente);

A continuacin se crea un objeto Font con un estilo Font.PLAIN y un tamao de 10.
Los otros estilos disponibles son ITALIC, BOLD y BOLD+ITALIC.
Font thisFont;
...

thisFont = new Font("Arial", Font.PLAIN, 10);

Posteriormente es posible crear un nuevo objeto Font a partir de un nombre de
fuente, estilo y tamao, que pueden seleccionarse de distintos combo. Al
seleccionarse el tamao el valor de item es de tipo cadena, por lo que se debe
convertir a entero para poder crear la nueva fuente.
public void cambiarFuente(String nf, int nest, String ntam){
Integer nuevoTam = new Integer(ntam);
int tam = nuevoTam.intValue();
thisFont = new Font(nf, nest, tam);
repaint();
}
`


Para controlar la fuente que se utiliza para dibujar el texto, es necesario enviar los
atributos de la fuente al contexto Graphics2D antes de renderizar. Los atributos de
la fuente se envan pasando un objeto Font al mtodo setFont. En este ejemplo, los
atributos son envidos al construir el nuevo objeto Font y la cadena se dibuja en el
centro del componente usando esta fuente. Cada vez que se modifiquen los
atributos, se construye un nuevo objeto Font y se enva al contexto Graphics 2D en
el metodo Paint() para que sean redibujados. El mtodo getFontMetrics permite
medir la longitud en pxeles de la cadena considerando los nuevos atributos, de
manera que siempre se dibuje en el centro del componente.
g2.setFont(thisFont);
String cadena = "Seleccione una fuente, tamao y estilo para modificarme";
FontMetrics medida = g2.getFontMetrics();
int ancho = medida.stringWidth( cadena );
int alto = medida.getHeight();
//Dibuja la cadena en el centro del panel correspondiente
g2.drawString( cadena, w/2-ancho/2, h/2-alto/2 ); }

El cdigo completo del ejemplo, comentado se muestra a continuacin:
/*
* Ejemplo de seleccin de fuentes. Construido para el Tutorial
* de Java2D de Sun Microsystems.
*/

import java.lang.Integer;
import java.awt.*;
import java.awt.font.*;
import java.util.Vector;

public class FontSelection extends JApplet implements ItemListener {
JLabel lblFuente, lblTamano, lblEstilo;
pnlLetra fontC;
JComboBox cmbFuente, cmbTamano, cmbEstilo;
int i = 0;


String nuevafuente = "Fuente sin seleccionar";
int nuevoestilo = 0;
String nuevotam = "10";


getContentPane().setLayout( new BorderLayout() );

JPanel pnlSuperior = new JPanel();
JPanel pnlLetra = new JPanel();
JPanel pnlTamano = new JPanel();
JPanel pnlEstilo = new JPanel();
JPanel pnlEstiloTamano = new JPanel();

//Se asignan las distribuciones para cada panel
pnlSuperior.setLayout( new BorderLayout() );
pnlLetra.setLayout( new GridLayout( 2, 1 ) );
pnlTamano.setLayout( new GridLayout( 2, 1 ) );
pnlEstilo.setLayout( new GridLayout( 2, 1 ) );
pnlEstiloTamano.setLayout( new BorderLayout() );

//Incluye cada panel dentro de los correspondientes para visualizar mejor
//la distribucin de la aplicacin
pnlSuperior.add( BorderLayout.WEST, pnlLetra );
pnlEstiloTamano.add( BorderLayout.WEST, pnlTamano );
pnlEstiloTamano.add( BorderLayout.CENTER, pnlEstilo );
pnlSuperior.add( BorderLayout.CENTER, pnlEstiloTamano );

getContentPane().add( BorderLayout.NORTH, pnlSuperior );

//Asigna caractersticas a la etiqueta de texto Fuentes
lblFuente = new JLabel();
lblFuente.setText("Fuentes");
Font newFont = getFont().deriveFont(1);
lblFuente.setFont(newFont);
lblFuente.setHorizontalAlignment(JLabel.CENTER);
pnlLetra.add(lblFuente);


//Asigna caractersticas a la etiqueta de texto Tamao
lblTamano = new JLabel();
lblTamano.setText("Tamao");
lblTamano.setFont(newFont);
lblTamano.setHorizontalAlignment(JLabel.CENTER);
pnlTamano.add(lblTamano);

//Asigna caractersticas a la etiqueta de texto Estilo
lblEstilo = new JLabel();
lblEstilo.setText("Estilo");
lblEstilo.setFont(newFont);
lblEstilo.setHorizontalAlignment(JLabel.CENTER);
pnlEstilo.add(lblEstilo);

/*Se obtienen las fuentes disponibles en el contexto grfico
*se asignan al objeto vector que posteriomente es enviado al combo
*de Fuentes. Se asigna un mximo de items para mostrar en el combo de 9 fila
*y se predetermina como fuente inicial, la primera fuente ubicada (indice 0).
*Finalmente se agrega el combo al panel correspondiente.
*/
GraphicsEnvironment gEnv = GraphicsEnvironment.getLocalGraphicsEnvironment();
String envcmbFuente[] = gEnv.getAvailableFontFamilyNames();
Vector vector = new Vector();
for ( int i = 1; i < envcmbFuente.length; i++ ) {
vector.addElement(envcmbFuente[i]);
}
cmbFuente = new JComboBox( vector );
cmbFuente.setMaximumRowCount( 9 );
cmbFuente.addItemListener(this);
nuevafuente = envcmbFuente[0];
pnlLetra.add(cmbFuente);

/*Se asignan los valores para el combo de tamao, los posibles tamaos sern 10,
*12,14,16,18. Se define como mximo nmero de filas a mostrar 9. Se agrega el
combo
*al panel correspondiente.


*/
cmbTamano = new JComboBox( new Object[]{ "10", "12", "14", "16", "18"} );
cmbTamano.setMaximumRowCount( 9 );
cmbTamano.addItemListener(this);
pnlTamano.add(cmbTamano);

/*Se arma el combo de estilo a partir de los estilos predeterminados.se siguen los mismo
*pasos que para los combos anteriores y finalmente se incluye el combo en el panel
*correspondiente.
*/
cmbEstilo = new JComboBox( new Object[]{
"PLAIN",
"BOLD",
"ITALIC",
"BOLD & ITALIC"} );
cmbEstilo.setMaximumRowCount( 9 );
cmbEstilo.addItemListener(this);
cmbTamano.setMaximumRowCount( 9 );
pnlEstilo.add(cmbEstilo);

/*Se especifican las caracteristicas del Panel que va a contener el texto.
*/
fontC = new pnlLetra();
fontC.setBackground(Color.white);
getContentPane().add( BorderLayout.CENTER, fontC);
}

/* El siguiente mtodo detecta cuando se ha realizado la modificacin de item
* en alguno de los combos.
*/
public void itemStateChanged(ItemEvent e) {
if ( e.getStateChange() != ItemEvent.SELECTED ) {
return;
}

Object combomodif = e.getSource(); //Obtiene el objeto combo que cambi de item


//Compara con cada uno de los combos posibles
if ( combomodif == cmbFuente ) {
nuevafuente = (String)cmbFuente.getSelectedItem();
} else if ( combomodif == cmbEstilo ) {
i = cmbEstilo.getSelectedIndex();
nuevoestilo = i;
} else {
nuevotam = (String)cmbTamano.getSelectedItem();
}
//Cambia la fuente del contexto, de acuerdo con los nuevos atributos seleccionados en los combo
fontC.cambiarFuente(nuevafuente, nuevoestilo, nuevotam);
}

JFrame f = new JFrame("Ejemplo de renderizado de texto");
});

JApplet Seleccion = new FontSelection();
f.getContentPane().add(Seleccion, BorderLayout.CENTER);
Seleccion.init();
f.setVisible(true);
}

}

class pnlLetra extends JPanel {

Font thisFont;

public pnlLetra(){
thisFont = new Font("Arial", Font.PLAIN, 10);
}


// Este mtodo es el que modifica la fuente de acuerdo con los nuevos parmetros
public void cambiarFuente(String nf, int nest, String ntam){
Integer nuevoTam = new Integer(ntam);
int tam = nuevoTam.intValue();
thisFont = new Font(nf, nest, tam);
repaint();
}

public void paintComponent (Graphics g) {
super.paintComponent( g );
int w = getWidth();
int h = getHeight();

g2.setColor(Color.darkGray);
g2.setFont(thisFont);
String cadena = "Seleccione una fuente, tamao y estilo para modificarme";
FontMetrics medida = g2.getFontMetrics();
int ancho = medida.stringWidth( cadena );
int alto = medida.getHeight();
//Dibuja la cadena en el centro del panel correspondiente
g2.drawString( cadena, w/2-ancho/2, h/2-alto/2 );
}
}

Se recomienda revisar el ejemplo y plantear una solucin para cuando el texto no
cabe en una lnea y se requiere separarlo, como en el caso de un prrafo.

Leccin 39 Imgenes
El API 2D de Java implementa un nuevo modelo de imagen que permite la
manipulacin de imgenes de resolucin fija almacenadas en memoria. La clase
BufferedImage es una nueva clase Image en el paquete java.awt.image, que puede
usarse para manipular datos de una imagen recuperados desde un archivo o una
URL. Por ejemplo, se puede usar un BufferedImage para implementar doble bfer .
Las clases BufferedImage y BufferedImageOp tambin permiten realizar una gran


variedad de operaciones de filtrado de imgenes como blur o sharpen. El modelo
de imagen productor/consumidor proporcionado en las versiones anteriores del
JDK se mantiene por razones de compatibilidad.

39.1 El modelo de imgenes de modo inmediato y el BufferedImage
El modelo de imgenes en "modo inmediato" permite manipular y mostrar
imgenes de pixeles mapeados cuyos datos estn almacenados en memoria. Es
posible acceder a los datos de la imagen en una gran variedad de formatos y usar
varios tipos de operaciones de filtrado para manipular los datos.
BufferedImage es la clase clave del API del modo-inmediato. Esta clase maneja
una imagen en memoria y proporciona mtodos para almacenar, interpretar y
dibujar cada dato de pixel. Un BufferedImage puede ser renderizado en un contexto
Graphics o en un contexto Graphics2D.
Un BufferedImage es
esencialmente un Image con un
bfer de datos accesible. Un
BufferedImage tiene un
ColorModel y un Rster de los
datos de la imagen.

Figura 66 Clase BufferedImage (Sun Microsystems)

El ColorModel proporciona una interpretacin de color de los datos de los pxeles
de la imagen. El Rster representa las coordenadas rectangulares de la imagen,
mantiene los datos de la imagen en memoria, y proporciona un mecanismo para
crear mltiples subimagenes de un slo bfer de imagen. El Rster tambin
proporciona mtodos para acceder a pxeles especficos dentro de la imagen.

39.2 Filtrado de un BufferedImage
El API Java 2D define varias operaciones de filtrado para objetos BufferedImage.
Cada operacin de proceso de imgenes est incluida en una clase que
implementa la interfaz BufferedImageOp. La manipulacin de imgenes se realiza
en el mtodo filter. La clase BufferedImageOp en el API Java 2D soporta:
Transformacin afin
Escalado


Modificacin de Aspecto
Combinacin Linear de Bandas
Conversin de color
Convolucin.
Para filtrar un BufferedImage usando una de las clases de operacin de imagense
debe:
1. Constuir una instancia de una de las clases BufferedImageOp:
AffineTransformOp, BandCombineOp, ColorConvertOp, ConvolveOp,
LookupOp , o RescaleOp.
2. Llamar al mtodo de operacin filter, pasando el BufferedImage que se
desea filtrar y el BufferedImage donde se quiere almacenar el resultado.
El siguiente ejemplo, tomado del Tutorial de Java 2D de Sun Microsystems ilustra
el uso de cuatro operaciones de filtrado de imagenes: low-pass, sharpen, lookup, y
rescale. Se hicieron algunas modificaciones, pues se presentaban errores al cargar
los archivos de imagen. El resultado de la ejecucin es la pantalla que se muestra
en la Figura 67.
El filtro sharpen se realiza usando un ConvolveOp. Convolucin es el proceso de
hacer ms pesado el valor de cada pixel en una imagen con los valores de los
pixeles vecinos. La mayora de los algoritmos de filtrado espacial estn basados en
las operaciones de convolucin.
Para construir y aplicar este tipo de filtrado al BufferedImage, este ejemplo usa un
cdigo similar al del siguiente fragmento.
public static final float[] SHARPEN3x3 = {
0.f, -1.f, 0.f,
-1.f, 5.0f, -1.f,
0.f, -1.f, 0.f};
BufferedImage dstbimg = new BufferedImage(iw,ih,BufferedImage.TYPE_INT_RGB);
Kernel kernel = new Kernel(3,3,SHARPEN3x3);
ConvolveOp cop = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
cop.filter(srcbimg,dstbimg);


Figura 67 Ejemplo de tratamiento de imgenes
El objeto Kernel define matemticamente cmo se ve afectada la salida de cada
pixel en su rea inmediata. La definicin del Kernel determina el resultado del filtro.
El cdigo completo de la aplicacin, que contiene los cuatro filtros aplicados a las
imgenes es el siguiente:
/*
* Ejemplo de aplicacin de filtros utilizando BufferedImage y BufferedImageOp.
* Versin modificada del ejemplo del Tutorial de Java 2D de Sun Microsystems.
*/

import java.awt.*;
import java.awt.image.*;
import java.awt.geom.AffineTransform;
import java.awt.font.TextLayout;


import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.event.WindowAdapter;
import java.applet.*;
import java.net.URL;

public class ImageOps extends Applet {

private BufferedImage vectorbi[];
public static final float[] SHARPEN3x3_3 = {
0.f, -1.f, 0.f,
-1.f, 5.f, -1.f,
0.f, -1.f, 0.f};


vectorbi = new BufferedImage[4];
String nombresimg[] = { "canocristales01.jpg", "canocristales01.jpg", "rioapaporis01.jpg",
"rioapaporis01.jpg"};
for ( int i = 0; i < vectorbi.length; i++ ) {

//Obtiene la imagen a partir del nombre de archivo correspondiente
Image imagen = Toolkit.getDefaultToolkit().getImage(nombresimg[i]);

/* El objeto MediaTracker, optimiza el proceso de cargado de la imagen al bloquear la tarea hasta
que
* la imagen est totalmente cargada, con lo que se elimina el parpadeo que se produce al ir
* presentndose en la pantalla partes de esa imagen que no est totalmente cargada.
*/
try {
MediaTracker tracker = new MediaTracker(this);
tracker.addImage(imagen, 0);
tracker.waitForID(0);
}
catch ( Exception e ) { }
int iancho = imagen.getWidth(this);


int ialto = imagen.getHeight(this);
vectorbi[i] = new BufferedImage(iancho, ialto, BufferedImage.TYPE_INT_RGB);

//Crea un contexto grfico a partir de la imagen
Graphics2D completa = vectorbi[i].createGraphics();
//Dibuja en el contexto la imagen
completa.drawImage(imagen,0,0,this);
}
}

g2.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RNDER_QUALITY);
//Tamao del applet para calcular los tamaos de imagen y sus posiciones
int anchoap = getSize().width;
int altoap = getSize().height;

g2.setColor(Color.black);
float[][] datos = {{0.1f, 0.1f, 0.1f, // Matriz del Filtro
0.1f, 0.2f, 0.1f,
0.1f, 0.1f, 0.1f},
SHARPEN3x3_3};

String Descrip[] = { "Convolve LowPass", "Convolve Sharpen",
"LookupOp", "RescaleOp"};
for ( int i = 0; i < vectorbi.length; i++ ) {
int iancho = vectorbi[i].getWidth(this);
int ialto = vectorbi[i].getHeight(this);
int x = 0, y = 0;

AffineTransform transformacion = new AffineTransform();
transformacion.scale((anchoap-14)/2.0/iancho, (altoap-34)/2.0/ialto);

BufferedImageOp bitrans = null;//BufferedImage donde quedar la modificada


BufferedImage biorig = new BufferedImage(iancho,ialto,BufferedImage.TYPE_INT_RGB);
//BufferedImage original

switch ( i ) {
case 0 :
case 1 : x = i==0?5:anchoap/2+3; y = 15;
Kernel kernel = new Kernel(3,3,datos[i]);
ConvolveOp cop = new ConvolveOp(kernel,
ConvolveOp.EDGE_NO_OP,
null);
cop.filter(vectorbi[i],biorig);
bitrans = new AffineTransformOp(transformacion,
AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
break;
case 2 : x = 5; y = altoap/2+15;
byte chlut[] = new byte[256];
for ( int j=0;j<200 ;j++ )
chlut[j]=(byte)(256-j);
ByteLookupTable blut=new ByteLookupTable(0,chlut);
LookupOp lop = new LookupOp(blut, null);
lop.filter(vectorbi[i],biorig);
bitrans = new AffineTransformOp(transformacion,AffineTransformOp.TYPE_BILINEAR);
break;
case 3 : x = anchoap/2+3; y = altoap/2+15;
RescaleOp rop = new RescaleOp(1.1f,20.0f, null);
rop.filter(vectorbi[i],biorig);
bitrans = new AffineTransformOp(transformacion,AffineTransformOp.TYPE_BILINEAR);
}

//Dibuja la imagen en el contexto grfico en la correspondiente x e y.
g2.drawImage(biorig,bitrans,x,y);
//Dubija el texto
TextLayout texto = new TextLayout(Descrip[i], g2.getFont(),g2.getFontRenderContext());
texto.draw(g2, (float) x, (float) y-4);
}
}


JFrame f = new JFrame("Tratamiento de imgenes");
});

Applet elapplet = new ImageOps();
f.getContentPane().add("Center", elapplet);
elapplet.init();
f.pack();
f.show();
}
}

Leccin 40 Tcnica de Doble Bfer
Cuando un grfico es complejo o se usa repetidamente, se puede reducir el tiempo
que tarda en mostrarse renderizndolo primero en un bfer fuera de pantalla y
luego copiando el bfer en la pantalla. Esta tcnica, llamada doble bfer, se usa
frecuentemente para animaciones.
Nota!!! Cuando dibujamos sobre un componente Swing, ste utiliza
automticamente el doble bfer
Un BufferedImage puede usarse fcilmente como un bfer fuera de pantalla. Para
crear un BufferedImage cuyo espacio, color, profundidad y distribucin de pixeles
corresponden exactamente a la ventana en la que sern dibujados, se llama al
mtodo createImage del componente. Si se necesita un control sobre el tipo de la
imagen fuera de la pantalla o su transparencia, se puede construir directamente un
objeto BufferedImage y usarlo como un bfer fuera de pantalla.
Para dibujar dentro de una imagen almacenada, se llama al mtodo
BufferedImage.createGraphics para obtener el objeto Graphics2D; luego se llama a
los mtodos de dibujo apropiados del Graphics2D. Todo el API de dibujo de Java
2D puede usarse cuando se dibuja sobre un BufferedImage que est siendo
utilizado como un bfer fuera de pantalla.


Cuando est listo para copiar el BufferedImage en la pantalla, simplemente se
llama al mtodo drawImage sobre el contexto Graphics2D del componente y se le
pasa el BufferedImage.
El siguiente ejemplo permite al usuario arrastrar un rectngulo sobre la ventana del
applet. En lugar de dibujar el rectngulo en cada posicin del cursor, para
proporcionar informacin al usuario, se usa un BufferedImage como bfer fuera de
la pantalla. Cuando se arrastra el rectngulo, es renderizado dentro del
BufferedImage en cada nueva posicin y el BufferedImage se copia en la pantalla.
El ejemplo fue tomado del Tutorial de Sun Microsystems adems de ilustrar el uso
del doble bfer le puede servir para ilustrar un posible proceso de animacin. Lea
atentamente el cdigo comentado.

Figura 68 Ejecucin del ejemplo de doble bfer

import java.awt.*;
import java.applet.Applet;
import java.awt.image.*;

public class BufferedShapeMover extends Applet{

static protected Label lblTexto;

public void init(){
//Define la organizacin del applet
setLayout(new BorderLayout());


add(new BSMCanvas());
lblTexto = new Label("Arrastre el rectngulo dentro del rea");
add("South", lblTexto);
}

Frame f = new Frame("Ejemplo de uso de doble bfer");
});
Applet applet = new BufferedShapeMover();
f.add("Center", applet);
applet.init();
f.pack();
f.show();
}

}

class BSMCanvas extends Canvas implements MouseListener, MouseMotionListener{

Rectangle rect = new Rectangle(0, 0, 100, 50);
BufferedImage bi;
Graphics2D contexto;

/* Toma las coordenas de la ltima vez que el usuario presiono el mouse y se ejecut
* el evento mousePressed.
*/
int ult_x, ult_y;
boolean primeraVez = true;
TexturePaint texturaRelleno, texturaFilete;
Rectangle area;

/* Esta variable es True si el usuario di clic o movio el mouse fuera del area del rectangulo,
* falso de lo contrario
*/


boolean estaFuera = false;

//Esta es la clase que define el fondo donde actua el rectngulo
public BSMCanvas(){
addMouseMotionListener(this);
addMouseListener(this);

// Crea el patrn para el relleno
bi = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB);
contexto = bi.createGraphics();
contexto.setColor(Color.blue);
contexto.fillRect(0, 0, 7, 7);
contexto.setColor(Color.cyan);
contexto.fillOval(0, 0, 2, 2);
Rectangle r = new Rectangle(0,0,5,5);
texturaRelleno = new TexturePaint(bi, r);
contexto.dispose();

//Crea el patrn para el filete
bi = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB);
contexto.setColor(Color.cyan);
contexto.fillRect(0, 0, 7, 7);
contexto.setColor(Color.blue);
contexto.fillOval(0, 0, 2, 2);
r = new Rectangle(0,0,5,5);
texturaFilete = new TexturePaint(bi, r);
contexto.dispose();
}

// Maneja el evento cuando se ha dado clic a un botn del mouse.
public void mousePressed(MouseEvent e){

ult_x = rect.x - e.getX();
ult_y = rect.y - e.getY();


// Chequea si el usuario dio clic dentro del rectangulo y se mantiene all
if(rect.contains(e.getX(), e.getY())){
updateLocation(e);
} else {
BufferedShapeMover.lblTexto.setText("Posicione el cursor en el rectngulo y luego
arrastre");
estaFuera = true;
}
}

// Maneja el evento cuando el usuario arrastra el mouse miesntras mantiene presionado el botn.
public void mouseDragged(MouseEvent e){

if(!estaFuera){
updateLocation(e);
} else {
arrastre");
}
}

// Maneja el evento cuando el usuario suelta el boton del mouse
public void mouseReleased(MouseEvent e){

/* Chequea si el cursor est dentro del rectngulo cuando el usuario suelta el botn del mouse
* e.getX y e.getY proporcionan las coordenadas donde se solt el botn
*/
if(rect.contains(e.getX(), e.getY())){
updateLocation(e);
} else {
arrastre");
estaFuera = false;
}
}

// Este mtodo es requerido por el MouseListener, no se implementa.


public void mouseMoved(MouseEvent e){}

// Estos mtodos son requeridos por el MouseMotionListener no se implementa.
public void mouseClicked(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseEntered(MouseEvent e){}

// Este mtodo es el que actualiza la localizacin del rectngulo
public void updateLocation(MouseEvent e){

rect.setLocation(ult_x + e.getX(), ult_y + e.getY());

/* Si el mtodo chequearRect retorna verdadero actualiza el contenido del texto para que
* muestre la localizacin actual del rectngulo, de lo contrario muestr un mensaje
*/
if (chequearRect()) {
BufferedShapeMover.lblTexto.setText("Rectngulo localizado en " +
rect.getX() + ", " +
rect.getY());
} else {
BufferedShapeMover.lblTexto.setText("Por favor no intente arrastrar el rectngulo"+
" fuera del rea");
}
repaint();
}

public void paint(Graphics g){
update(g);
}

public void update(Graphics g){
Graphics2D g2 = (Graphics2D)g;

if(primeraVez){
Dimension dim = getSize();
int ancho = dim.width;
int alto = dim.height;


area = new Rectangle(dim);
bi = (BufferedImage)createImage(ancho, alto);
rect.setLocation(ancho/2-50, alto/2-25);
contexto.setStroke(new BasicStroke(10.0f));
primeraVez = false;
}

// Pone en blanco el rectngulo que se dibuj con anterioridad
contexto.setColor(Color.white);
contexto.clearRect(0, 0, area.width, area.height);

// Dibuja y rellena el rectngulo en la nueva posicin del bfer
contexto.setPaint(texturaFilete);
contexto.draw(rect);
contexto.setPaint(texturaRelleno);
contexto.fill(rect);

// Dibuja la imagen del bfer en la pantalla.
g2.drawImage(bi, 0, 0, this);
}

/* Esta funcin chequea si el rectngulo se encuentra dentro de la ventana del applet.
* Si no se encuentra dentro del applet, el se redibuja de forma que quede al lado del
* margen de la ventana.
*/
boolean chequearRect(){
if (area == null) {
return false;
}
if(area.contains(rect.x, rect.y, 100, 50)){
return true;
}
int nuevo_x = rect.x;
int nuevo_y = rect.y;


if((rect.x+100)>area.width){
nuevo_x = area.width-99;
}
if(rect.x < 0){
nuevo_x = -1;
}
if((rect.y+50)>area.height){
nuevo_y = area.height-49;
}
if(rect.y < 0){
nuevo_y = -1;
}
rect.setLocation(nuevo_x, nuevo_y);
return false;
}

}

CAPTULO 9 API 3D de JAVA
A continuacin se presenta un tutorial introductorio al API 3D de Java, tomado de la
traduccin realizada por Juan Antonio Palos al Tutorial de Sun Microsystems. Slo
contempla la etapa de reconocimiento del modelamiento inicial con el API 3D de
Java, se espera que el estudiante profundice su estudio a partir de sus
necesidades e intereses individuales.
El API Java 3D es un interface para escribir programas que muestran e interactan
con grficos tridimensionales. Java 3D es una extensin estndar del JDK 2 de
Java. El API Java 3D proporciona una coleccin de constructores de alto-nivel para
crear y manipular geometras 3D y estructuras para dibujar esta geometra. Java
3D proporciona las funciones para creacin de imgenes, visualizaciones,
animaciones y programas de aplicaciones grficas 3D interactivas.


Leccin 41 Lo bsico de Java 3D
El API 3D de Java es un rbol de clases Java que sirven como interfaz para
sistemas de renderizado de grficos tridimensionales y un sistema de sonido. El
programador trabaja con constructores de alto nivel para crear y manipular objetos
geomtricos en 3D. Estos objetos geomtricos residen en un universo virtual, que
luego es renderizado. El API est diseado con flexibilidad para crear universos
virtuales precisos de una mplia variedad de tamaos, desde astronmicos a
subatmicos.
A pesar de toda esta funcionalidad, el API es sencillo de usar. Los detalles de
renderizado se manejan automticamente. Aprovechndose de los Threads Java,
el renderizador Java 3D es capaz de renderizar en paralelo. El renderizador
tambin puede optimizarse automticamente para mejorar el rendimiento del
renderizado.
Un programa Java 3D crea ejemplares de objetos Java 3D y los sita en un
estructura de datos de escenario grfico. Este escenario grfico es una
composicin de objetos 3D en una estructura de rbol que especifica
completamente el contenido de un universo virtual, y cmo va a ser renderizado.
Los programas Java 3D pueden escribirse para ser ejecutados como aplicaciones
solitarias o como applets en navegadores que hayan sido extendidos para soportar
Java 3D, o mbos.

Leccin 42 Empezar con Java 3D
Todo programa Java 3D est, al menos parcialmente, ensamblado por objetos del
rbol de clases Java 3D. Esta coleccin de objetos describe un universo virtual,
que va a ser renderizado. El API define unas 100 clases presentadas en el paquete
javax.media.j3d.
Hay cientos de campos y mtodos en las clases del API Java 3D. Sin embargo, un
sencillo universo virtual que incluya animacin puede construirse con unas pocas
clases. Esta seccin describe un conjunto mnimo de objetos y sus interacciones
para renderizar un universo virtual.
Esta seccin incluye el desarrollo de un sencillo pero completo programa Java 3D,
llamado HelloJava3Dd.java, que muestra un cubo giratorio. El programa de ejemplo
se desarrolla de forma incremental, y se presenta en varias versiones, para
demostrar cada parte del proceso de programacin Java 3D.


Adems del paquete corazn de Java 3D, se usan otros paquetes para escribir
programas Java 3D. Uno de estos paquetes es com.sun.j3d.utils al que
normalmente se hace referencia como clases de utilidades de Java 3D. El paquete
de las clases corazn incluye slo las clases de menor nivel necesarias en la
programacin Java 3D.
Las clases de utilidades son adiciones convenientes y poderosas al corazn. Estas
clases se dividen en cuatro categoras: cargadores de contenidos, ayudas a la
construccin del escenario grfico, clases de geometra y utilidades de
conveniencia.
Al utilizar las clases de utilidades se reduce significativamente el nmero de lneas
de cdigo en un programa Java 3D. Adems de las clases de los paquetes corazn
y de utilidades de Java 3D, todo programa 3D usa clases de los paquetes java.awt
y javax.vecmath.
En el resto del texto, el trmino objeto visual se utilizar para hacer referencia a un
"objeto del escenario grfico" (por ejemplo, un cubo o una esfera). El trmino objeto
slo se usar para referirse a un ejemplar de una clase. El trmino contenido se
usar para referirnos a objetos visuales en un escenario grfico como un todo.

42.1 Construir un Escenario Grfico
Un universo virtual Java 3D se crea desde un escenario grfico. Un escenario
grfico se crea usando ejemplares de clases Java 3D. El escenario grfico est
ensamblado desde objetos que definen la geometra, los sonidos, las luces, la
localizacin, la orientacin y la apariencia de los objetos visuales y sonoros.
Una definicin comn de un escenario grfico es una estructura de datos
compuesta de nodos y arcos. Un nodo es un elemento dato y un arco es una
relacin entre elementos datos. Los nodos en un escenario grfico son los
ejemplares de las clases Java 3D. Los arcos representan dos tipos de relaciones
entre ejemplares Java 3D.
La relacin ms comn es padre-hijo. Un nodo Group puede tener cualquier
nmero de hijos, pero slo un padre. Un nodo hoja slo puede tener un padre y no
puede tener hijos. La otra relacin es una referencia. Una referencia asocia un
objeto NodeComponent con un nodo del escenario grfico. Los objetos
NodeComponent definen la geometra y los atributos de apariencia usados para
renderizar los objetos visuales.


Un escenario grfico Java 3D est construido de objetos nodos con relaciones
padre-hijo formando una estructura de rbol. En una estructura de rbol, un nodo
es el raz. Se puede acceder a otros nodos siguiendo los arcos desde el raz. Los
nodos de un rbol no forman bucles. Un escenario grfico est formado desde los
rboles con races en los objetos Locale. Los NodeComponents y las referencias a
arcos no forman parte del escenario grfico.
Slo existe un camino desde la raz de un rbol a cada una de las hojas; por lo
tanto, slo hay un camino desde la raz hasta el escenario grfico de cada nodo
hoja. El camino desde la raz de un escenario grfico hasta una hoja especificada
es el camino al escenario grfico del nodo hoja. Como un camino de un escenario
grfico trata exactamente con un sola hoja, hay un camino de escenario grfico
para cada hoja en el escenario.
Todo camino de escenario grfico en un escenario grfico Java 3D especifica
completamente la informacin de estado de su hoja. Esta informacin incluye, la
localizacin, la orientacin y el tamao del objeto visual. Consecuentemente, los
atributos visuales de cada objeto visual dependen slo de su camino de escenario
grfico. El renderizador Java 3D se aprovecha de este hecho y renderiza las hojas
en el orden que l determina ms eficiente. El programador Java 3D normalmente
no tiene control sobre el orden de renderizado de los objetos.
Las representaciones grficas de un escenario grfico pueden servir como
herramienta de diseo y/o documentacin para los programas Java 3D. Los
escenarios grficos se dibujan usando smbolos grficos estndar como se ve en la
Figura 69. Los programas Java 3D podran tener ms objetos que los que hay en
su escenario grfico.
Para disear un universo virtual Java 3D se dibuja un escenario grfico usando un
conjunto de smbolos estndar. Despus de completar el diseo, este escenario
grfico es la especificacin para el programa. Despus de completar el programa,
el mismo escenario grfico es una representacin concisa del programa
(asumiendo que se sigui la especificacin).


Figura 69 Notacin utilizada para la representacin de un escenario grfico

Cada uno de los smbolos mostrados al lado izquierdo de la Figura 69 representa
un slo objeto cuando se usa en un escenario grfico. Los dos primeros smbolos
representan objetos de clases especficas: VirtualUniverse y Locale. Lo siguientes
tres smbolos de la izquierda representan objetos de las clases Group, Leaf, y
NodeComponent. Estos tres smbolos normalmente tienen anotaciones para indicar
la subclase del objeto especfico. El ltimo smbolo se usa para representar otras
clases de objetos.
El smbolo de la flecha slida representa una relacin padre-hijo entre dos objetos.
La flecha punteada es una referencia a otro objeto. Los objetos referenciados
pueden ser compartidos entre diferentes ramas de un escenario grfico. En la
Figura 70, se puede observar un sencillo escenario grfico.


Figura 70 Ejemplo de escenario grfico

Es posible crear un escenario grfico ilegal. Se puede ver uno en la Figura 71. Este
escenario es ilegal porque viola las propiedades de un DAG. El problema son los
dos objetos TransformGroup(TG) que tienen al mismo objeto Shape3D como hijo.
Recuerda que una hoja slo puede tener un padre. En otras palabras, slo puede
haber un camino desde el objeto Locale hasta la hoja (o un camino desde la hoja
hasta el objeto Locale).

Figura 71 Ejemplo de escenario grfico ilegal


Es posible pensar que la estructura mostrada en la Figura 71 define tres objetos
visuales en un universo virtual. Pero el escenario grfico define dos objetos
visuales que re-usan el objeto visual (Shape3D) del lado derecho de la figura.
Conceptualmente, cada objeto TransformGroup que apadrina al ejemplar
compartido de Shape3D podra situar una imagen en el objeto visual en diferentes
localizaciones. Sin embargo, es un escenario grfico ilegal porque el arco padre-
hijo no forma un rbol. En este ejemplo, el resultado es que el objeto Shape3D
tiene ms de un padre.
Las explicaciones del rbol y de las estructuras DAG son correctas. Sin embargo,
el sistema de ejecucin Java 3D reporta el error en trminos de la relacin hijo-
padre. Un resultado de la limitacin de la estructura de rbol es que cada objeto
Shape3D est limitado a un slo padre. Para el ejemplo de la Figura 61, se lanzar
una excepcin 'multiple parent' en el momento de la ejecucin. La Figura 72, con
un padre para cada objeto Shape3D, muestra una posible solucin para este
escenario grfico.

Figura 72 Posible solucin al escenario grfico ilegal
Cada escenario grfico tiene un slo VirtualUniverse. Este objeto tiene una lista de
objetos Locale. Un objeto Locale proporciona una referencia a un punto en el
universo virtual. Se puede pensar en los objetos Locale como marcas de tierra que
determinan la localizacin de los objetos visuales en el universo virtual.
Es tcnicamente posible para un programa Java 3D tener ms de un objeto
VirtualUniverse, y as definir ms de un universo virtual. Sin embargo, no hay
ninguna forma de comunicacin entre los universos virtuales. Adems, un objeto de


un escenario grfico no puede existir en ms de un universo virtual. Es altamente
recomendable usar uno y slo un ejemplar de VirtualUniverse en cada programa
Java 3D.
Mientras que un objeto VirtualUniverse podra referenciar muchos objetos Locale,
la mayora de los programas Java 3D tiene un slo objeto Locale. Cada
objetoLocale puede servir de raz para varios sub-grficos del escenario grfico.
Por ejemplo, si se hace referencia a la Figura 70 se podr observar las dos ramas
sub-grficas que salen desde el objeto Locale.
Un objeto BranchGroup es la raz de un sub-grfico, o rama grfica. Hay dos
categorias de escenarios sub-grficos: la rama de vista grfica y la rama de
contenido grfico. La rama de contenido grfico especifica el contenido del universo
virtual - geometra, apariencia, comportamiento, localizacin, sonidos y luces. La
rama de vista grfica especifica los parmetros de visualizacin, como la posicin
de visualizacin y la direccin. Juntas, las dos ramas especifican la mayora del
trabajo que el renderizador tiene que hacer.

42.2 rbol de Clases de Alto Nivel del API Java 3D
En la Figura 73 se pueden ver los tres primeros niveles del rbol de clases del API
Java 3D. En esta parte del rbol aparecen las clases VirtualUniverse, Locale,
Group, y Leaf.


Figura 73 rbol de clases del API Java 3D

SceneGraphObject es la superclase de casi todas las clases corazn y de utilidad
de Java 3D. Tiene dos subclases: Node y NodeComponent. Las subclases de
Node proporcionan la mayora de los objetos de un escenario grfico. Un objeto
Node es un objeto nodo Group o un objeto nodo Leaf.

Clase Node
La clase Node es una superclase abstracta de las clases Group y Leaf. Esta clase
define algunos de los mtodos importantes de sus subclases. Las subclases de
Node componen escenarios grficos.

Clase Group
La clase Group es la superclase usada en especificacin de localizacin y
orientacin de objetos visuales en el universo virtual. Dos de las subclases de


Group son: BranchGroup y TransformGroup. En la representacin grfica de un
escenario grfico, los simbolos de Group (crculos) normalmente se anotan con BG
para BranchGroups, TG para TransformGroups, etc. La Figura 70 muestra algunos
ejemplos de esto.
Clase Leaf
La clase Leaf es la superclase usada para especificar la forma, el sonido y
comportamiento de los objetos visuales en el universo virtual. Algunas de las
subclases de Leaf son: Shape3D, Light, Behavior, y Sound. Estos objetos podran
no tener hijos pero podran referenciar a NodeComponents.
Clase NodeComponent
La clase NodeComponent es la superclase usada para especificar la geometra, la
apariencia, la textura y las propiedades de material de un nodo Shape3D (Leaf).
Los NodeComponents no forman parte del escenario grfico, pero son
referenciados por l. Un NodeComponent podra ser referenciado por ms de un
objeto Shape3D.

42.3 Receta para Escribir Programas Java 3D
Las subclases de SceneGraphObject son los ladrillos que se ensamblan en los
escenarios grficos. La lnea bsica de desarrollo de un programa Java 3D consiste
en siete pasos (a los que la especificacin del API Java 3D se referiere como un
Receta) presentados a continuacin. Esta receta puede usarse para ensamblar
muchos programas tiles de Java 3D.
1. Crear un Objeto Canvas3D
2. Crear un objeto VirtualUniverse
3. Crear un objeto Locale, adjuntarlo al objeto VirtualUniverse
4. Construir la rama de vista grfica
5. Crear un objeto View
6. Crear un objeto ViewPlatform
7. Crear un objeto PhysicalBody
8. Crear un objeto PhysicalEnvironment
9. Adjuntar los objetos ViewPlatform, PhysicalBody, PhysicalEnvironment, y
Canvas3D al objeto View
10. Construir la(s) rama(s) grfica(s) de contenido
11. Compilar la(s) rama(s) grfica(s)
12. Insertar los subgrficos dentro del objeto Locale


Esta receta ignora algunos detalles pero ilustra el concepto fundamental para toda
la programacin Java 3D: crear la rama grfica del escenario grfico es la
programacin principal. En vez de ampliar esta receta, los siguientes prrafos
explican una forma sencilla de construir un escenario grfico muy similar con
menos programacin.
Los programas Java 3D escritos usando la receta bsica tienen ramas de vista
grfica con idntica estructura. La regularidad de la estructura de las ramas de vista
grfica tambien se encuentra en la clase de utilidad SimpleUniverse. Los
ejemplares de esta clase realizan los pasos 2, 3 y 4 de la receta bsica. Usando la
clase SimpleUniverse en programacin Java 3D se reduce significativamente el
tiempo y el esfuerzo necesario para crear las ramas de vista grfica.
Consecuentemente, el programador tiene ms tiempo para concentrarse en el
contenido. Esto es de lo que se trata el escribir programas Java 3D.
La clase SimpleUniverse es un buen punto de inicio en la programacin Java 3D,
porque permite al programador ignorar las ramas de vista grfica. Sin embargo,
usar SimpleUniverse no permite tener varias vistas de un universo virtual.
La clase SimpleUniverse se usa en todos los ejemplos de programacin de este
tutorial.

La clase SimpleUniverse
El constructor de SimpleUniverse crea un escenario grfico que incluye un objeto
VirtualUniverse y Locale, y una rama de vista grfica completa. Esta rama grfica
creada usa un ejemplar de las clases de conveniencia ViewingPlatform y Viewer en
lugar de las clases corazn usadas para crear una rama de vista grfica. Observe
que SimpleUniverse slo usa indirectamente los objetos View y ViewPlatform del
corazn Java 3D. Los objetos SimpleUniverse suministran la funcionalidad de todos
los objetos que hay dentro del recuadro azul de la Figura 74.


Figura 74 Universo virtual mnimo proporcionado por la clase SimpleUniverse (en azul)
El paquete com.sun.j3d.utils.universe contiene SimpleUniverse, ViewingPlatform, y
clases Viewer de conveniencia.
Al usar los objetos SimpleUniverse la receta bsica se simplifica:
1. Crear un objeto Canvas3D
2. Crear un objeto SimpleUniverse que referencia al objeto Canvas3D
anterior
3. Personalizar el objeto SimpleUniverse
4. Construir la rama de contenido
5. Compilar la rama de contenido grfico
6. Insertar la rama de contenido grfico dentro del objeto Locale de
SimpleUniverse
Constructores de SimpleUniverse
Paquete: com.sun.j3d.utils.universe
Esta clase configura un entorno de usuario mnimo para obtener rpida y fcilmente
un programa Java 3D y ejecutarlo.
Esta clase de utilidad crea todos los objetos necesarios para la rama de vista
grfica. Especificamente crea los objetos Locale, VirtualUniverse, ViewingPlatform,
y Viewer (todos con sus valores por defecto). Los objetos tiene las relaciones
apropiadas para formar la rama de vista grfica.


SimpleUniverse proporciona toda la funcionalidad necesaria para muchas
aplicaciones Java 3D bsicas. Viewer y ViewingPlatform son clases de
conveniencia. estas clases usan las clases View y ViewPlatform del corazn Java.
SimpleUniverse() Construye un sencillo universo virtual.
SimpleUniverse(Canvas3D canvas3D) Construye un sencillo universo
virtual con una referencia al objeto Canvas3D nombrado.
El objeto SimpleUniverse crea una rama de vista grfica completa para un universo
virtual. Esta rama incluye un plato de imagen. Un plato de imagen es el rectngulo
conceptual donde se proyecta el contenido para formar la imagen renderizada. El
objeto Canvas3D, que proporciona una imagen en una ventana de nuestra pantalla,
puede ser el plato de imagen.
La Figura 75 muestra la relacin entre el plato de imagen, la posicin del ojo, y el
universo virtual. La posicin del ojo est detrs del plato de imagen. Los objetos
visuales delante del plato de imagen son renderizados en el plato de imagen. El
renderizado puede ser como una proyeccin de los objetos visuales sobre el plato
de imagen. Esta idea se ilustra con los cuatro proyectores de la imagen (lneas
punteadas).

Figura 75 Representacin del Plato de imagen y el ojo visor en el universo virtual

Por defecto, el plato de imagen est centrado en el origen de SimpleUniverse. La
orientacin por defecto es mirando hacia abajo el eje Z. Desde esta posicin, el eje
X es una lnea horizontal que atraviesa el plato de imagen con los valores positivos
hacia la derecha. El eje Y es una lnea vertical que atraviesa el centro del plato de
imagen, con los valores positivos arriba. Consecuentemente, el punto (0,0,0) es el
centro del plato de imagen.


Los tpicos programas Java 3D mueven la vista haca atrs (z positivo) para hacer
que los objetos se acerquen, al origen dentro de la vista. La clase SimpleUniverse
tiene un miembro que es un objeto de la clase ViewingPlatform. Esta clase tiene un
mtodo setNominalViewingTransform que selecciona la posicin del ojo para que
est centrado en (0, 0, 2.41) buscando en direccin z negativa hacia el origen.

El Mtodo ViewingPlatform setNominalViewingTransform()
Paquete: com.sun.j3d.utils.universe
La clase ViewingPlatform se usa para configurar la rama de vista grfica de un
escenario grfico Java 3D en un objeto SimpleUniverse. Este mtodo normalmente
se usa en conjuncin con el mtodo getViewingPlatform de la clase
SimpleUniverse.
void setNominalViewingTransform()
Selecciona la distancia nominal de la vista a una distancia de aproximadamente
2,42 metros en la vista de transformacin de un SimpleUniverse. Desde esta
distancia y con el campo de vista por defecto, los objetos con 2 metros de altura o
de anchura generalmente entran en el plato de imagen.
Despus de crear los objetos Canvas3D y SimpleUniverse, el siguiente paso es la
creaccin de la rama de contenido grfico. La regularidad de estructura encontrada
en la rama de vista grfica no existe para la rama de contenido grfico. La rama de
contenido vara de un programa a otro haciendo imposible obtener los detalles de
su construccin en una receta. Esto tambin significa que no hay una clase de
"contenido sencillo" para ningn universo que podamos querer ensamblar.
Despus de crear la rama de contenido grfico, se inserta dentro del universo
usando el mtodo addBranchGraph de SimpleUniverse. Este mtodo toma un
ejemplar de BranchGroup como nico argumento. Este BranchGroup se aade
como hijo del objeto Locale creado por SimpleUniverse.
Algunos de los mtodos de SimpleUniverse correspondiente al paquete:
com.sun.j3d.utils.universe, se muestran a continuacin:
void addBranchGraph(BranchGroup bg) Se usa para aadir Nodos al objeto
Locale del escenario grfico creado por el SimpleUniverse. Se usa para aadir una
rama de contenido grfico al universo virtual.


ViewingPlatform getViewingPlatform() Se usa para recuperar el objeto
ViewingPlatform del SimpleUniverse ejemplarizado. Este mtodo se usa con el
mtodo setNominalViewingTransform() de ViewingPlatform para ajustar la
localizacin de la posicin de vista.

42.4 Alguna Terminologa Java 3D
Insertar una rama grfica dentro de un Locale la hace viva, y consecuentemente,
cada uno de los objetos de esa rama grfica tambin estn vivos. Hay algunas
consecuencias cuando un objeto se convierte en vivo. Los objetos vivos estan
sujetos a renderizacin. Los parmetros de los objetos vivos no pueden ser
modificados a menos que la capacidad correspondiente haya sido seleccionada
especificamente antes de que el objeto est vivo.
Los objetos BranchGroup pueden ser compilados. Compilar un BranchGroup lo
convierte a l y a todos sus ancestros en una forma ms eficiente para el
renderizado. Compilar los objetos BranchGroup est recomendado como el
ltimo paso antes de hacerlo vivir. Es mejor compilar solo los objetos
BranchGroup insertados dentro de objetos Locale
El mtodo BranchGroup compile() compila la fuente BranchGroup asociada con
este objeto creado y coloca en memoria cach el escenario grfico compilado.
Los conceptos de compilado y vivo se implementan en la clase
SceneGraphObject. Abajo se pueden ver los dos mtodos de la clase
SceneGraphObject que se relacionan con estos conceptos.
SceneGraphObject es la superclase usada para crear un escenario grfico
incluyendo Group, Leaf, y NodeComponent. SceneGraphObject proporciona varios
mtodos y campos comunes para sus subclases:
boolean isCompiled() Devuelve una bandera indicando si el nodo forma parte
de un escenario grfico que ha sido compilado.
boolean isLive() Devuelve una bandera que indica si el nodo forma parte de un
escenario grfico vivo.
Observe que no hay un paso "Empezar a renderizar" en ninguna de las recetas
anteriores. El renderizador Java 3D empieza a funcionar en un bucle infinito cuando
una rama grfica que contiene un ejemplar de View se vuelve vivo en un universo
virtual. Una vez arrancado, el renderizador Java 3D realiza las operaciones
mostradas en el siguiente listado:


while(true) {
Procesos de entrada
If (peticin de salida) break
Realiza comportamientos
Atraviesa el escenario grfico
y renderiza los objetos visuales
}
Limpieza y salida

Las secciones anteriores explicaban la construccin de un sencillo universo virtual
sin una rama de contenido grfico. La creaccin de esta rama es el objetivo de las
siguientes secciones.

Leccin 43 Un Ejemplo de la aplicacin de la receta
El programa Java 3D tpico empieza definiendo una nueva clase que extiende la
clase Applet. El ejemplo HelloJava3Da.java es una clase definida para extender la
clase Applet. Los programas Java 3D podran escribirse como aplicaciones, pero
usar applets ofrece una forma ms sencilla de producir una aplicacin con
ventanas.
La clase principal de un programa Java 3D normalmente define un mtodo para
construir la rama de contenido grfico. En el ejemplo HelloJava3Da dicho mtodo
est definido como createSceneGraph(). Los pasos de la receta sencilla se
implementan en el constructor de la clase HelloJava3Da, que se muestra en la
Figura 76.


Figura 76 Fragmento del cdigo de HelloJava3Da.java
El paso 1, crear un objeto Canvas3D, se completa en la lnea 23.
El paso 2, crear un objeto SimpleUniverse, se hace en la lnea 31.
El paso 2a, personalizar el objeto SimpleUniverse, se realiza en la lnea 35.
El paso 3, construir la rama de contenido, se realiza en la llamada al mtodo
createSceneGraph() de la lnea 27.
El paso 4, compilar la rama de contenido grfico, se hace en la lnea 28.
Finalmente el paso 5, insertar la rama de contenido grfico en el objeto Locale del
SimpleUniverse, se completa en la lnea 37.
El paso 3 de esta sencilla receta es crear la rama de contenido grfico. Esta rama
se crea en el fragmento de cdigo que se muestra en la Figura 77.

Figura 77 Fragmento para la creacin de la rama
de contenido grfico
Probablemente sea la rama de
contenido grfico ms sencilla
posible. Contiene un objeto grfico
esttico, un ColorCube que se
observa en la lnea 45. ste est
localizado en el origen del sistema de
coordenadas del universo virtual, el
valor del lado del cubo es de 0.4,
considerando que el tamao total del
applet es 1.0.

La clase HelloJava3Da est derivada de Applet pero el programa puede ejecutarse
como una aplicacin con el uso de la clase MainFrame. La clase Applet se usa
como clase base para hacer ms fcil la escritura de un programa Java 3D que se


ejecuta en una ventana. MainFrame proporciona un marco AWT (ventana) para un
applet permitiendo que el applet se ejecute como una aplicacin.
El tamao de la ventana de la
aplicacin resultante se
especifica en la construccin
de la clase MainFrame.

Figura 78 Mtodo main que crea la ventana invocando
MainFrame

Los tres fragmentos de cdigo anteriores (Figura 76, Figura 77 y Figura 78) forman
un programa Java 3D completo cuando se usan las sentencias import adecuadas.
A continuacin se pueden ver las sentencias import necesarias para compilar la
clase HelloJava3Da. Las clases ms comunmente usadas en Java 3D se
encuentran en los paquetes javax.media.j3d, o javax.vecmath.

Figura 79 Sentencias import para
HelloJava3Da.java
En este ejemplo, slo la clase de
utilidad ColorCube se encuentra en el
paquete com.sun.j3d.utils.geometry.
La mayora de los programas Java 3D
tienen las sentencias import mostradas
en el fragmento de la Figura 79.

En el programa de ejemplo HelloJava3Da.java, slo se sito un objeto grfico en
una nica localizacin. En la Figura 80 se observa el escenario grfico resultante:

Figura 80 Escenario grfico de HelloJava3Da.java


La imagen que proporciona la ejecucin del cdigo completo se muestra en la
Figura 81.

Figura 81 Ejecucin de HelloJava3Da.java
Como no se explica cada lnea de cdigo del ejemplo HelloJava3Da, las ideas
bsicas de ensamblar un programa Java 3D deberan estar claras habiendo ledo el
ejemplo. La siguiente seccin presenta cada una de las clases usadas en el
programa.

43.1 Clases Java 3D Usadas en HelloJava3Da
Para aadir un poco de entendimiento del API Java 3D y el ejemplo HelloJava3Da
aqu se presenta una sntesis de las clases del API Java 3D usadas en
HelloJava3Da.
Clase BranchGroup
Los objetos de este tipo se usan para formar escenarios grficos. Los ejemplares
de BranchGroup son la raz de los sub-grficos. Los objetos BranchGroup son los
nicos que pueden ser hijos de los objetos Locale. Los objetos BranchGroup
pueden tener varios hijos. Los hijos de un objeto BranchGroup pueden ser otros
objetos Group o Leaf.
El constructor por defecto de BranchGroup es:
BranchGroup() Los ejemplares de BranchGroup sirven como raz para las
ramas del escenario grfico; los objetos BranchGroup son los nicos objetos que
pueden insertarse en un conjunto de objetos Locale.


Clase Canvas3D
La clase Canvas3D deriva de la clase Canvas del AWT. Por lo menos un objeto
Canvas3D debe ser referenciado en la rama de vista grfica del escenario grfico.
El constructor de Canvas3D es:
Canvas3D(GraphicsConfiguration graphicsconfiguration) Construye e
inicializa un nuevo objeto Canvas3D que el Java 3D puede renderizar dando un
objeto GraphicsConfiguration vlido. Es una extensin de la clase Canvas del AWT.

Clase Transform3D
Los objetos Transform3D representan transformaciones de geometras 3D como
una traslacin o una rotacin. Estos objetos normalmente slo se usan en la
creaccin de un objeto TransformGroup. Primero, se construye el objeto
Transform3D, posiblemente desde una combinacin de objetos Transform3D.
Luego se construye el objeto TransformGroup usando el objeto Transform3D.
Un objeto de transformacin generalizado se representa internamente como una
matriz de 4x4 doubles de punto flotante. La representacin matemtica es la mejor
forma. Un objeto Transform3D no se usa en un escenario grfico. Se usa para
especificar la transformacin de un objeto TransformGroup.
El constructor por defecto de Transform3D
Transform3D() Construye un objeto Transform3D que representa la matriz de
identidad (no la transformacin).
Un objeto Transform3D puede representar una traslacin, una rotacin, un
escalado, o una combinacin de stas. Cuando se especifica una rotacin, el
ngulo se expresa en radianes. Una rotacin completa es 2 PI radianes. Una forma
de especificar ngulos es usar la constante Math.PI. Otra forma es especificar los
valores directamente. Algunas aproximaciones son: 45 es 0.785, 90 es 1.57, y
180 es 3.14.
A continuacin se presenta una lista parcial de mtodos de Transform3D
void rotX(double angle) Selecciona el valor de esta transformacin a una
rotacin en contra del sentido del reloj sobre el eje-x. El ngulo se especifica en
radianes.


void rotY(double angle) Selecciona el valor de esta transformacin a una
rotacin en contra del sentido del reloj sobre el eje-y. El ngulo se especifica en
radianes.
void rotZ(double angle) Selecciona el valor de esta transformacin a una
rotacin en contra del sentido del reloj sobre el eje-z. El ngulo se especifica en
radianes.
void set(Vector3f translate) Selecciona el valor transacional de esta matriz al
valor del parmetro Vector3f, y selecciona los otros componentes de la matriz como
si sta transformacin fuera una matriz idntica.

Clase TransformGroup
Como una subclase de la clase Group, los ejemplares de TransformGroup se usan
en la creaccin de escenarios grficos y tienen una coleccin de objetos nodos
como hijos. Los objetos TransformGroup contienen transformaciones geomtricas
como traslaciones y rotaciones. La transformacin normalmente se crea en un
objeto Transform3D, que no es un objeto del escenario grfico.
Los contructores de TransformGroup son:
TransformGroup() Construye e inicializa un TransformGroup usando una identidad
de transformacin.
TransformGroup(Transform3D t1) Construye e inicializa un TransformGroup
desde un objeto Transform3D t1 pasado como parmetro.
La transformacin contenida en un objeto Transform3D se copia a un objeto
TransformGroup o cuando se crea el TransformGroup, o usando el mtodo
setTransform(). As:
void setTransform(Transform3D t1) Selecciona el componente de transformacin
de este TransformGroup a partir del valor de de la transformacin pasada en el
parmetro t1.

Clase Vector3f
Vector3f es una clase matemtica que se encuentra en el paquete javax.vecmath
para especificar un vector usando tres valores de punto flotante para las
coordenadas x, y, e z. Los objetos Vector se usan frecuentemente para


especificar traslaciones de geometras. Los objetos Vector3f no se usan
directamente en la construccin de un escenario grfico. Se usan para especificar
las traslaciones, superficies normales, u otras cosas.
A continuacin se muestran los constructores de Vector3f
Vector3f() Construye e inicializa un Vector3f a (0,0,0).
Vector3f(float x, float y, float z) Construye e inicializa un Vector3f desde las
coordenadas x, y, z especificadas.

Clase ColorCube
ColorCube es una clase de utilidad que se encuentra en el paquete
com.sun.j3d.utils.geometry que define la geometra y colores de un cubo
centrado en el origen y con diferentes colores en cada cara, ColorCube extiende la
clase Shape3D, por lo tanto, es un nodo hoja. Si un cubo sin rotar se sita en el
origen (como en HelloJava3Da), se ver la cara roja desde la localizacin de visin
nominal. Los otros colores son azul, magenta, amarillo, verde y cian.
Los coonstructores de ColorCube son:
ColorCube() Construye un cubo de color del tamao por defecto. Por defecto, una
esquina est situada a 1 unidad de cada uno de los ejes desde el origen,
resultando un cubo que est centrado en el origen y tiene 2 unidades de alto, de
ancho y de profundo.
ColorCube(double scale) Construye un cubo de color escalado por el valor
especificado. El tamao por defecto es 2 unidades de lado. El ColorCube resultante
tiene esquinas en (scale, scale, scale) y (-scale, -scale, -scale).
.
Leccin 44 Rotacin de objetos
Una simple rotacin del cubo puede hacer que se vea ms de una de sus caras. El
primer paso es crear la transformacin deseada usando un objeto Transform3D.
El fragmento de cdigo de la Figura 82 incorpora un objeto TransformGroup en el
escenario grfico para rotar el cubo sobre el eje x. Primero se crea la
transformacin de rotacin usando el objeto rotate de Transform3D, en la linea 24.


Figura 82 Fragmento de cdigo para rotar un objeto
La rotacin se especifica usando el
mtodo rotX() de la lnea 27.
Entonces se crea el objeto
TransformGroup en la lnea 31
para contener la transformacin de
rotacin.
Dos parmetros especifican la
rotacin: el eje de revolucin, y el
ngulo de rotacin.

El eje se elige seleccionando el mtodo apropiado (rotX, rotY o rotZ). El ngulo de
rotacin es el valor que se le pasa como argumento. Como el ngulo de rotacin se
especifica en radianes, el valor PI/4 es 1/8 de una rotacin completa, o 45 grados.
Solamente las lneas 24 y 27 ejecutan la rotacin en un eje.
Despus de crear el objeto Transform3D, rotate, se usa en la creaccin del objeto
TransformGroup objRotate (lnea 31). El objeto Transform3D se usa en el
escenario grfico. Entonces el objeto objRotate hace que ColorCube sea su hijo
(lnea 34). A su vez, el objeto objRoot hace a objRotate como su hijo (lnea 33).
La rama de contenido grfico ahora incluye un objeto TransformGroup en el camino
del escenario grfico hacia el objeto ColorCube. Cada uno de los caminos del
escenario grfico es necesario. El objeto BranchGroup es el nico que puede ser
hijo de un Locale.
El objeto TransformGroup es el nico que
puede cambiar la localizacin, la orientacin,
o el tamao de un objeto visual. En este caso
el objeto TransformGroup cambia la
orientacin. Por supuesto, el objeto
ColorCube es necesario para suministrar el
objeto visual. A continuacin se puede
observar el escenario grfico producido por
el fragmento de la Figura 82.

Figura 83 Escenario grfico para la rotacin
del cubo

El resultado de la ejecucin de la rotacin en un eje y al modificar el eje se se
puede observar en la siguiente secuencia grfica.


Figura 84 Resultado de rotar el
cubo en X

cubo en Y

cubo en Z

44.1 Combinacin de transformaciones
Frecuentemente un objeto visual se traslada y se rota, o se rota sobre dos ejes. En
cualquier caso, se especifican dos transformaciones diferentes para un slo objeto
visual. Las dos transformaciones pueden combinarse en una matriz de
transformaciones y contenerse en un slo objeto TransformGroup. Para el ejemplo
se pedir revisar nuevamente el cdigo de la Figura 82, correspondiente al
programa HelloJava3Db.java. Hasta el momento nos habamos fijado solamente en
las lneas 24 y 27 para rotar el objeto visual en un solo eje, al incluir las dems
lneas se obtendr una combinacin de rotaciones.
Para crear estas dos rotaciones simultneas se requiere combinar dos objetos
Transform3D de rotacin. El ejemplo rota el cubo sobre los ejes x e y. Se crean dos
objetos Transform3D, uno por cada rotacin (lneas 24 y 25). Las rotaciones
individuales se especifican para los dos objetos TransformGroup (lneas 27 y 28).
Luego las rotaciones se combinan mediante la multiplicacin de los objetos
Transform3D (lnea 29). La combinacin de las dos transformaciones se carga en
el objeto TransformGroup (lnea 31).

El cdigo completo del ejemplo HelloJava3Db.java es el siguiente:
/* @(#)HelloJava3Db.java 1.1 00/09/22 13:55
* Copyright (c) 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
* HelloJava3Db dibuja un cubo simple rotado 45 en x y 36 en y


*/
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;
import javax.vecmath.*;

public class HelloJava3Db extends Applet {

public BranchGroup createSceneGraph() {
// Crea la raz del rbol
BranchGroup objRoot = new BranchGroup();

// El objeto rotate contiene la matriz de transformacin
Transform3D rotate = new Transform3D();
Transform3D tempRotate = new Transform3D();

rotate.rotX(Math.PI/4.0d);
tempRotate.rotY(Math.PI/5.0d);
rotate.mul(tempRotate);

TransformGroup objRotate = new TransformGroup(rotate);

objRoot.addChild(objRotate);
objRotate.addChild(new ColorCube(0.4));

// Compila la escena grfica
objRoot.compile();
return objRoot;
} // Fin del mtodo CreateSceneGraph que crea la escena


// Crea una escena simple relacionada con el universo virtual
public HelloJava3Db() {
GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();

Canvas3D canvas3D = new Canvas3D(config);
add("Center", canvas3D);

BranchGroup scene = createSceneGraph();

SimpleUniverse simpleU = new SimpleUniverse(canvas3D);

simpleU.getViewingPlatform().setNominalViewingTransform();

simpleU.addBranchGraph(scene);
} // Fin del constructor HelloJava3Db

public static void main(String[] args) {
Frame frame = new MainFrame(new HelloJava3Db(), 256, 256);
} // Fin del mtodo main
} // Fin de la clase HelloJava3Db

En la Figura 87 se puede ver el escenario grfico creado en HelloJava3Db.java. La
rama de vista grfica es la misma producida en HelloJava3Da, que est construida
por un SimpleUniverse y representada por una gran estrella. La rama de contenido
grfico ahora incluye un TransformGroup en el camino del escenario grfico hacia
el objeto ColorCube. En la Figura 88 se puede observar el resultado de la
ejecucin.


Figura 87 Escenario grfico para varias
transformaciones

Figura 88 Ejecucin de HelloJava3Db con
rotacin en X e Y

44.2 Capacidades y Rendimiento
El escenario grfico construido por un programa Java 3D podra usarse
directamente para renderizar. Sin embargo, la representacin no es muy eficiente.
La flexibilidad construida dentro de cada objeto escenario grfico (que no se van a
discutir en este tutorial) crean un representacin sub-optima del universo virtual.
Para mejorar el rendimiento de la renderizacin se usa una representacin ms
eficiente del universo virtual.
Java 3D tiene una representacin interna para una universo virtual y los mtodos
para hacer la conversin. Hay dos formas para hacer que el sistema Java 3D haga
la conversin de la representacin interna. Una forma es compilar todas las ramas
grficas. La otra forma es insertar una rama grfica en un universo virtual para
darle vida.
Compilar Contenidos
El objeto BranchGroup tiene un mtodo compilador. Llamando a este mtodo se
convierte la rama grfica completa que hay debajo del BranchGroup a la
representacin interna de Java 3D de la rama grfica. Adems de la conversin, la
representacin interna podra optimizarse de una o varias maneras.
Las posibles optimizaciones no se especifican en el API Java 3D. Sin embargo, se
puede ganar en eficiencia de varias formas. Una de las posibles optimizaciones es
combinar TransformGroups con caminos de escenario grfico. Por ejemplo, si un


escenario grfico tiene dos objetos TransformGroup en una relacion padre-hijo
pueden ser representados por un objeto TransformGroup. Otra posibilidad es
combinar objetos Shape3D que tienen una relacin esttica fsica. Estos tipos de
optimizaciones se hacen posibles cuando las capacidades no se configuran.
La Figura 89 presenta una representacin conceptual de la conversin a una
representacin ms eficiente. El escenario grfico del lado izquierdo es compilado y
transformado en la representacin interna mostrada en el lado derecho. La figura
slo representa el concepto de representacin interna, no como Java 3D realmente
lo hace.

Figura 89 Representacin conceptual del proceso de compilar un escenario grfico

Capacidades
Una vez que una rama grfica empieza a vivir o es compilada el sistema de
renderizado Java 3D la convierte a una representacin interna ms eficiente. El
efecto ms importante de esta conversin es la mejora del rendimiento de
renderizado.
Pero tambin tiene otros efectos, uno de ellos es fijar el valor de transformaciones y
otros objetos en el escenario grfico. A menos que especificamente se le
proporcionen al programa, este no tendr la capacidad de cambiar los valores de
los objetos del escenario grfico una vez que estn vivos.
Hay casos en que un programa necesita la capacidad de cambiar estos valores
despus de que estn vivos. Por ejemplo, cambiar el valor de un objeto
TransformGroup crea animaciones. Para que esto suceda, la transforamcin debe


poder cambiar despus de estar viva. La lista de parmetros a los que se puede
acceder, y de que forma, se llama capacidades del objeto.
Cada SceneGraphObject tiene un conjunto de bits de capacidad. Los valores de
estos bits determinan que capacidades existen para el objeto despus de
compilarlo o de darle vida. El conjunto de capacidades vara con la clase.
SceneGraphObject es la superclase de casi cualquier clase usada para crear un
escenario grfico, incluyendo Group, Leaf, y NodeComponent.
A continuacin se presenta la lista parcial de mtodos de SceneGraphObject.
void clearCapability(int bit) Borra el bit de capacidad especificado.
boolean getCapability(int bit) Recupera el bit de capcidad especificado.
void setCapability(int bit) Configura el bit de capacidad especificado.
Como ejemplo, para poder leer el valor de la transformacin representada por un
objeto TransformGroup, esta capacidad debe activarse antes de compilarlo o darle
vida. De forma similar, para poder cambiar el valor de la transformacin en un
objeto TransformGroup, su capacidad de escribir transformacin debe configurarse
antes de compilarlo o darle vida. Intentar hacer un cambio en un objeto vivo o
compilado para el que la propiedad adecuada no se ha configurado resultar en
una excepcin.
En la siguiente seccin, las animaciones se crean usando una transformacin de
rotacin que vara con el tiempo. Para que esto sea posible, el objeto
TransformGroup debe tener su capacidad ALLOW_TRANSFORM_WRITE
activada antes de que sea compilado o se le de vida.
A continuacin se presenta la lista parcial de capacidades de TransformGroup. Las
dos capacidades listadas aqu son las nicas definidas por TransformGroup. ste
hereda varias capacidades de sus clases ancestros: Group y Node. La
configuracin de capacidades se puede seleccionar, eliminar o recuperar usando
los mtodos definidos en SceneGraphObject.
ALLOW_TRANSFORM_READ Especifica que el nodo TransformGroup permite
acceder a la informacin de transformacin de su objeto.
ALLOW_TRANSFORM_WRITE Especifica que el nodo TransformGroup permite
escribir la informacin de transformacin de su objeto.
Las capacidades tambin controlan el acceso a otros aspectos de un objeto
TransformGroup. Los objetos TransformGroup heredan configuracin de


capacidades de sus clases ancestros: Group y Node. En el siguiente bloque de
referencia se pueden ver ver algunas de esas capacidades.
Lista Parcial de Capacidades de Group: TransformGroup hereda varios bits de
capacidades de sus clases ancestros.
ALLOW_CHILDREN_EXTEND Permite que se puedan aadir hijos al nodo Group
despus de que est compilado o vivo.
ALLOW_CHILDREN_READ Permite que se puedan leer las referencias a los
hijos del nodo Group despus de que est compilado o vivo.
ALLOW_CHILDREN_WRITE Permite que se puedan escribir las referencias a
los hijos del nodo Group despus de que est compilado o vivo.

Leccin 45 Aadir Comportamiento de Animacin
En Java 3D, Behavior es una clase para especificar animaciones o interacciones
con objetos visuales. El comportamiento puede cambiar virtualmente cualquier
atributo de un objeto visual. Un programador puede usar varios comportamientos
predefinidos o especificar un comportamiento personalizado. Una vez que se ha
especificado un comportamiento para un objeto visual, el sistema Java 3D actualiza
automticamente la posicin, la orientacin, el color, u otros atributos del objeto
visual.
La distincin entre animacin e interaccin es si el comportamiento es
activado en respuesta al paso del tiempo o en respuesta a actividades del
usuario, respectivamente.
Cada objeto visual del universo virtual puede tener su propio comportamiento
predefinido. De hecho, un objeto visual puede tener varios comportamientos. Para
especificar un comportamiento para un objeto visual, el programador crea objetos
que especifiquen el comportamiento, aade el objeto visual al escenario grfico y
hace las referencias apropiadas entre los objetos del escenario grfico y los objetos
Behavior.
En un universo virtual con muchos comportamientos, se necesita una significante
potencia de clculo para calcular los comportamientos. Como tanto el renderizador
como el comportamiento usan el mismo procesador, es posible que la potencia de
clculo que necesita el comportamiento degrade el rendimiento del renderizado.


Java 3D permite al programador manejar este problema especificando un lmite
espacial para que el comportamiento tenga lugar. Este lmite se llama regin
programada. Un comportamiento no est activo a menos que el volumen de
activacin de ViewPlatform interseccione con una regin progamada del
Behavior. En otras palabras, si nadie en el bosque ve el rbol caer, ste no cae. La
caracterstica de regin programada hace ms eficiente a Java 3D en el manejo de
universos virtuales con muchos comportamientos.
Un Interpolator es uno de las muchas clases de comportamientos predefinidos en
el paquete corazn de Java 3D. Basado en una funcin de tiempo, el objeto
Interpolator manipula los parmetros de un objeto del escenario grfico. Por
ejemplo, para el RotationInterpolator, manipula la rotacin especificada por un
TransformGroup para afectar la rotacin de los objetos visuales que son
ancestros de TransformGroup.
La siguiente lista enumera los pasos que se requieren para especificar una
animacin con un objeto Interpolator. Los cinco pasos forman una receta para
crear un comportamiento de animacin con interpolacin:
1. Crear un TransformGroup fuente. Selecciona la capacidad
ALLOW_TRANSFORM_WRITE.
2. Crear un objeto Alpha (funcin de tiempo en Java 3D). Especifica los
parmetros de tiempo para el alpha.
3. Crear el objeto Interpolator. Tiene referencias con los objetos Alpha y
TransformGroup. Personalizar los parmetros del comportamiento.
4. Especificar la regin programada. Configurar la regin programada para
el comportamiento.
5. Hacer el comportamiento como hijo del TransformGroup

45.1 Ejemplo de Comportamiento: HelloJava3Dc
El fragmento de cdigo de la Figura 90 muestra un ejemplo completo del uso de las
clases interpoladoras para crear una animacin. La animacin creada con este
cdigo es una rotacin contina con un tiempo de rotacin total de 4 segundos.


Figura 90 Cdigo para la creacin de la escena con comportamiento RotationInterpolator

El paso 1 de la receta es crear el objeto TransformGroup para modificarlo durante
la ejecucin. El objeto TransformGroup fuente de un interpolador debe tener
activada la capacidad de escritura. El objeto TransformGroup llamado objSpin se
crea en la lnea 25. La capacidad de escritura de objSpin se selecciona en la lnea
26.
El paso 2 es crear un objeto Alpha para dirigir la interpolacin. Los dos parmetros
especificados en la lnea 34 del fragmento de cdigo son el nmero de
interacciones del bucle y el tiempo de un ciclo. El valor de "-1" especifica un bucle
contnuo. El tiempo se especifica en milisegundos por lo que el valor de 4000
significa 4 segundos. Por lo tanto, el comportamiento es rotar cada cuatro
segundos.
El paso 3 de la receta es crear el objeto Interpolator. El objeto
RotationInterpolator se crea en la lnea 36. El interpolador debe tener referencias
a la transformacin fuente y al objeto alpha. Esto se consigue en el constructor. En
este ejemplo se usa el comportamiento por defecto del RotationInterpolator para
hacer una rotacin completa sobre el eje y.
El paso 4 es especificar una regin programada. Se usa un objeto
BoundingSphere con sus valores por defecto. El objeto BoundingSphere se crea
en la lnea 40. La esfera se configura como los lmites del comportamiento en la
lnea 41.
El paso final, el 5, hace del comportamiento un hijo del TransformGroup. Esto se
consigue en la lnea 42.
Este fragmento de cdigo se usa con otros fragmentos anteriores para crear el
programa de ejemplo HelloJava3Dc.java. Al ejecutar la aplicacin veremos como


se renderiza el ColorCube con un comportamiento de rotacin cada cuatro
segundos.

Figura 91 Escenario grfico incluyendo
comportamiento
El programa HelloJava3Dc crea el
escenario grfico de la Figura 91. El objeto
rotation es tanto hijo del TransformGroup
como una referencia a l. Aunque esta
relacin parece violar las restricciones de
bucles dentro del escenaio grfico, no lo
hace. Recuerda que los arcos de
referencia (flecha punteada) no son parte
del escenario grfico. La lnea punteada
desde el Behavior hacia el
TransformGroup es esta referencia.

La ejecucin del ejemplo HelloJava3Dc proporciona la siguiente ventana grfica:

Figura 92 Ejecucin del ejemplo HelloJava3Dc.java

45.2 Clases que intervienen para programar el comportamiento de animacin
Una accin de comportamiento puede ser cambiar la localizacin
(PositionInterpolator), la orientacin (RotationInterpolator), el tamao
(ScaleInterpolator), el color (ColorInterpolator), o la transpariencia
(TransparencyInterpolator) de un objeto visual. Como se mencion antes, los
Interpolators son clases de comportamiento predefinidas. Todos los
comportamientos mencionados son posibles sin usar un Interpolator; sin embargo,


los interpolators hacen mucho ms sencilla la craccin de comportamientos. Las
clases Interpolators existen para proporcionar otras acciones, incluyendo
combinaciones de estas acciones.
Clase RotationInterpolator
Esta clase se usa para especificar un comportamiento de rotacin de un objeto
visual o de un grupo de objetos visuales. Un objeto RotationIterpolator cambia un
objeto TransformGroup a una rotacin especififca en repuesta a un valor de un
objeto Alpha. Como el valor de este objeto cambia cada vez, la rotacin tambin
cambia. Un objeto RotationInterpolator es flexible en la especificacin del eje de
rotacin, el ngulo de inicio y el ngulo final.
Para rotaciones constantes sencillas, el objeto RotationInterpolator tiene el
siguiente constructor que puede usarse para eso:
RotationInterpolator(Alpha alpha, TransformGroup target) Este constructor usa
valores por defecto de algunos parmetros del interpolador para construir una
rotacin completa sobre el eje y, usando el TransformGroup especificado. Los
parmetros son:
alpha: la funcin de variacin de tiempo para referencia.
target: el objeto TransformGroup a modificar.
El objeto TransformGroup de un interpolador debe tener la capacidad de escritura
activada.
Mapear una accin en el tiempo se hace usando un objeto Alpha. La especificacin
de este objeto puede ser compleja.

Clase Alpha
Los objetos de la clase Alpha se usan para crear una funcin que vara en el
tiempo. La clase Alpha produce un valor entre cero y uno, inclusives. El valor que
produce depende de la hora y de los parmetros del objeto Alpha. Los objetos
Alpha se usan comunmente con un comportamiento Interpolator para proporcionar
animaciones de objetos visuales.
Alpha tiene diez parmetos, haciendo la programacin tremendamente flexible. Sin
entrar en detalles de cada parmetro, saber que un ejemplar de Alpha puede
combinarse fcilmente con un comportamiento para proporcionar rotaciones


sencillas, movimientos de pndulo, y eventos de una vez, como la apertura de
puertas o el lanzamiento de cohetes.
La clase Alpha proporciona objetos para convertir la hora en un valor alpha (un
valor entre 0 y 1). El objeto Alpha es efectivamente una funcin de tiempo que
genera valores alpha entre cero y uno. La funcin "f(t)" y las caractersticas del
objeto Alpha estn determinadas por parmetros definidos por el usuario:
Algunos constructores para el objeto Alpha son:
Alpha()
Bucle continuo con un periodo de un segundo.
Alpha(int loopCount, long increasingAlphaDuration)
Este constructor toma slo loopCount e increasingAlphaDuration como parmetros
y asigna los valores por defecto a todos los dems parmetros, resultando un
objeto Alpha que produce valores desde cero a uno crecientes. Esto se repite el
nmero de veces especificado por loopCount. Si loopCount es -1, el objeto alpha
se repite indefinidamente. El tiempo que tarde en ir desde cero hasta uno est
especificando en el segundo parmetro usando una escala de milisegundos.
Los parmetros:
loopCount: nmero de veces que se ejecuta este objeto alpha; un valor de -1
especifica un bucle indefinido.
increasingAlphaDuration: tiempo en milisegundos que tarda el objeto alpha en ir de
cero a uno.

Regin Progamada
Como se mencion anteriormente, cada comportamiento tiene unos lmites
programados. Estos lmites se configuran usando el mtodo
setSchedulingBounds de la clase Behavior.
Hay varias formas de especificar una regin programada, la ms sencilla es crear
un objeto BoundingSphere. Otras opciones incluyen BoundingBox y
BoundingPolytope.
La sintaxis del mtodo setShedulingBounds se presenta a continuacin:
void setSchedulingBounds(Bounds region)


Selecciona la regin programada del Behavior a unos lmites especificados por el
parmetro region.

Clase BoundingSphere
Especificar un lmite esfrico se consigue especificando un punto central y un rdio
para la esfera. El uso normal de este tipo de lmites es usar el centro a (0, 0, 0).
Entonces el radio se selecciona lo suficientemente grande como para contener el
objeto visual, incluyendo todas las posibles localizaciones del objeto.
Algunos de los constructores de BoundingSphere son:
BoundingSphere() Este constructor crea una lmite esfrico centrado en el origen
(0, 0, 0) con un radio de 1.
BoundingSphere(Point3d center, double radius) Construye e inicializa un
BoundingSphere usando el punto central y el rdio especificados.

45.3 Ejemplo de combinacin de Transformacin y Comportamiento:
HelloJava3Dd
Como se puede suponer, es posible combinar comportamientos con las
transformaciones de rotacin de los ejemplos anteriores. HelloJava3Dd.java hace
esto. En la rama de contenido grfico, hay objetos llamados objRotate y objSpin,
que distinguen entre la rotacin esttica y el comportamiento de rotacin (bucle
continuo) del objeto Cube respectivamente. El cdigo completo de la aplicacin que
permite dibujar la escena se presenta a continuacin.
/* @(#)HelloJava3Dd.java 1.1 00/09/22 13:55
* Copyright (c) 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
* Este ejemplo presenta la animacin continua de un cubo rotado
*/

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import com.sun.j3d.utils.applet.MainFrame;


import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;
import javax.vecmath.*;

public class HelloJava3Dd extends Applet {

public BranchGroup createSceneGraph() {
// Crea la raiz de la escena
BranchGroup objRoot = new BranchGroup();

// Estas son las lneas que permiten la rotacin
// combinada en los ejes X e Z.
Transform3D rotate = new Transform3D();
Transform3D tempRotate = new Transform3D();

rotate.rotX(Math.PI/4.0d);
tempRotate.rotZ(Math.PI/5.0d);
rotate.mul(tempRotate);

TransformGroup objRotate = new TransformGroup(rotate);

// Estas son las lneas que permiten el Behavior o
// animacin de rotacin continua, observada en HelloJava3Dc
TransformGroup objSpin = new TransformGroup();
objSpin.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

objRoot.addChild(objRotate);
objRotate.addChild(objSpin);

// Crea el ColorCube y lo agrega a la escena
objSpin.addChild(new ColorCube(0.4));

// Crea el objeto Behavior para desarrollar la animacin deseada
// que consiste en un rotacin continua sobre el eje Y cada 4 sg
Transform3D yAxis = new Transform3D();
Alpha rotationAlpha = new Alpha(-1, 4000);


RotationInterpolator rotator =
new RotationInterpolator(rotationAlpha,
objSpin, yAxis,
0.0f, (float) Math.PI*2.0f);

// Se especifica el rea activa de la escena como una Esfera
BoundingSphere bounds = new BoundingSphere();
rotator.setSchedulingBounds(bounds);
objSpin.addChild(rotator);

return objRoot;
} // Fin del mtodo CreateSceneGraph

public HelloJava3Dd() {
GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();

Canvas3D canvas3D = new Canvas3D(config);
add("Center", canvas3D);

BranchGroup scene = createSceneGraph();
scene.compile();

SimpleUniverse simpleU = new SimpleUniverse(canvas3D);

simpleU.getViewingPlatform().setNominalViewingTransform();

simpleU.addBranchGraph(scene);
} // Fin del constructor de HelloJava3Dd

public static void main(String[] args) {
Frame frame = new MainFrame(new HelloJava3Dd(), 256, 256);
} // Fin del mtodo main
} // Fin de la clase HelloJava3Dd


La representacin grfica de la escena y la ventana generada se muestran en las
siguientes figuras:

Figura 93 Escena grfica que combina
transformacin y comportamiento

Figura 94 Ejecucin del ejemplo
HelloJava3Dd.java


Fuentes documentales unidad 3
ALLIMANT, Frank. Archivo de ayuda construido a partir de la documentacin del
J2SE. [En lnea] http://www.confluent.fr/javadoc/indexe.html. Fecha de consulta:
Enero de 2006.
CREATIVE COMMONS. Definicin de Alpha Blending. [En lnea]
http://grafics.pina.be/definicio.php?id=21 Fecha de consulta: Enero de 2006.
FOLEY, James D.; VAN DAM, Andries; FEINER, Steven K. y HUGHES, John F.
Computer graphics: principles and practice, Addison Wesley, 1996.
FROUFE, Agustn. Tutorial de Java. [En lnea]
http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/introduccion/indice2.html#quinc
e. Fecha de consulta: Noviembre de 2005.
JAVA EN CASTELLANO. Grficos con Java 2D. Traduccin del Tutorial de Sun
Microsystems realizada por Juan Antonio Palos (ozito) [En lnea]
http://www.programacion.com/java/tutorial/2d/1/. Fecha de consulta: Noviembre de
2005.
MANZANEDO, Miguel Angel et al. Gua rpida de aprendizaje del lenguaje Java.
[En lnea] http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto.Oct98/index.htm. Fecha de
consulta: Noviembre de 2005.
OVERCLOCKERS. CL. Definicin del trmino Alpha Blending. [En lnea]
http://www.overclockers.cl/modules.php?name=enciclopedia&ver=4 Fecha de
consulta: Enero de 2006.
PLANETALIA.COM. Curso para la programacion de un juego de marcianitos en
Java. [En lnea] http://www.planetalia.com/cursos/Java-Invaders/JAVA-INVADERS-
00.clase. Fecha de consulta: Diciembre de 2005.
PLANETALIA.COM. Videojuegos programados en Java. [En lnea]
http://www.planetalia-exitos.com/videojuegos.jsp. Fecha de consulta: Diciembre de
2005.
PROGRAMACIN EN CASTELLANO. Curso de programacion Java en 3D.
Traduccin del curso de Sun Microsystems realizada por Juan Antonio Palos (ozito)
[En lnea] http://www.programacion.com/tutorial/3d/1/. Fecha de consulta:
Noviembre de 2005.


SUN MICROSYSTEMS: Sitio oficial para descargas y documentacin de Java. [En
lnea] http://java.sun.com/products/java-media/3D/downloads/index.html y
http://java.sun.com/products/java-media/3d Fecha de consulta: Diciembre de 2005.
WIKIPEDIA. Definicin de API. [En lnea] http://es.wikipedia.org/wiki/API. Fecha de
consulta: Enero de 2006.

Unidad 3 Trabajando Con Un API Grafica PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Unidad 3 Trabajando Con Un API Grafica PDF

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Escuela de Ciencias Bsicas, Tecnologa e Ingeniera

Potrebbero piacerti anche