Fundamentos de La Computacion Grafica
Fundamentos de La Computacion Grafica
Fundamentos de La Computacion Grafica
COMPUTACION GRAFICA
UNAD 2017
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
El API 2D de Java también hace posible la creación de librerías gráficas avanzadas, tales
como librerías de CAD-CAM y de gráficos o librerías de efectos especiales para imágenes,
así como la creación de imágenes y de filtros para archivos gráficos.
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.
Las últimas versionas del AWT proporcionaron un paquete simple para construir páginas
comunes HTML, pero no contemplaban características completas suficientes para dibujar
gráficos complejos, texto e imágenes. Como un paquete de dibujo simplificado, el AWT
encapsuló casos específicos de conceptos de renderizado más general. El API 2D de Java
provee un paquete de renderizado más flexible y con amplias características que expanden
el AWT para soportar gráficos generales y operaciones de renderizado.
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.
El mecanismo de renderizado básico es el mismo que en las versiones anteriores del JDK.
El sistema de dibujo o renderizado controla cuándo y cómo dibuja un programa. Cuando
un componente necesita ser mostrado, se llama automáticamente a su método paint o
update dentro del contexto Graphics apropiado.
Para usar las características del API 2D de Java, tenemos que forzar el objeto Graphics
pasado al método de dibujo de un componente a un objeto Graphics2D. Como se muestra
en el siguiente código:
El estilo de lápiz que se aplica al exterior de una forma. Este atributo stroke
permite dibujar líneas con cualquier tamaño de punto y patrón de
sombreado y aplicar finalizadores y decoraciones a la línea.
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 sólidos, gradientes o patrones.
Tomado de:
http://3.bp.blogspot.com/_ZZ6M_AOD6aQ/TTyfRUuyhBI/AAAAAAAAABQ/LubOHGKBY60/s1600/silla-ruedas-
perro-2.gif
setAttribute.
setStroke
setPaint
setComposite
setTransform
setClip
setFont
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
setRenderingHints
gp = new GradientPaint(0f,0f,blue,0f,30f,green);
g2.setPaint(gp);
Graphics2D proporciona los siguientes métodos generales de dibujado que pueden usarse
para dibujar cualquier primitivo geométrico, texto o imagen.
Draw: Dibuja el exterior de una forma geométrica primitiva usando los atributos
stroke y paint.
Fill: Dibuja cualquier forma geométrica primitiva rellenado su interior con el color o
patrón 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 patrón especificados por el
atributo paint.
drawImage: Dibuja la imagen especificada.
Aunque el sistema de coordenadas para una ventana o una pantalla podría 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
automáticamente durante el dibujado.
Espacio de usuario
El espacio del usuario representa una abstracción uniforme de todos los posibles sistemas
de coordenadas de dispositivos. El espacio de dispositivo para un dispositivo particular
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
podría tener el mismo origen y dirección del espacio del usuario, o podrían ser diferentes.
Sin embargo, las coordenadas del espacio del usuario son automáticamente transformadas
en las apropiadas para el espacio del dispositivo cuando se dibuja un objeto gráfico.
Frecuentemente, la plataforma subyacente o driver del dispositivo se utilizan para
desarrollar esta conversión.
Espacio de dispositivo
• GraphicsEnvironment
• GraphicsDevice
• GraphicsConfiguration
Transformaciones
32.2 Fuentes
Una cadena se asume de manera normal, en términos 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 más 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 carácter como una a con tílde 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 colección glyphs. Una única fuente puede tener
muchas versiones, tales como heavy, médium, oblique, ghotic y regular. Estas diferentes
versiones son llamadas caras (faces). Todas las caras de una fuente tienen un diseño
tipográfico similar y pueden ser reconocidas como miembros de una misma familia. En
otras palabras, una colección de glyphs con una forma particular de estilo conforma una
font face, una colección de formas de font faces forman una font family, y una colección
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 lógicos 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 especificación de fuentes por su nombre lógico y
también por su nombre de font face.
Usando el API 2D de Java es posible componer y dibujar cadenas que contienen múltiples
fuentes, de diferentes familias, caras, tamaños e incluso lenguajes. La apariencia del texto
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
está separada lógicamente de las características del texto. Los objetos Font se utilizan para
describir la apariencia, y la información de características del texto se almacena en objetos
TextLayout y TextAttibuteSet. Esta posibilidad hace más fácil de usar la misma fuente en
texto con diferentes características.
32.3 Imágenes
La apariencia del píxel puede definirse directamente o como un índice en una tabla de color
para una imagen. En imágenes que contienen muchos colores (más de 256), los píxeles
usualmente representan directamente el color, alpha y otras características de cada
localización de la pantalla. Tales imágenes tienden a ser muchos más grandes que las
imágenes de color indexado (indexed-color images), pero ellas son más realistas.
En una imagen de color indexado, los colores en la imagen están limitados a los colores
especificados en una tabla de colores, a menudo, el resultado es que sólo 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 imágenes de colores indexados
son más pequeñas. El formato de píxel es popular para las imágenes que contienen sólo
16 o 256 colores.
Las reglas para interpretar los píxeles están encapsuladas en un objeto ColorModel (por
ejemplo, los valores podrían ser interpretados de dos formas, como colores directos o
indexados). Para que un píxel 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 píxel en una imagen de modelo de color directo puede tomarse de una colección
de valores de las bandas para una localización en la pantalla.
Un objeto ColorSpace encapsula las reglas que gobiernan la forma como un conjunto de
valores numéricos que corresponden a un color particular. La implementación del
ColorSpace en el java.awt.color representa los espacios de color más popular, incluyendo
RGB y escala de grises. Es importante aclarar que un espacio de color no es una colección
de colores, el define las reglas como deberán ser interpretados los valores de colores
individuales.
Como ya se había mencionado, con el API 2D de Java es posible usar diferentes estilos de
lápices (filetes) y patrones de relleno. Como el texto está en últimas representado por un
conjunto de glyphs, a las cadenas de texto también se les puede aplicar atributos de filete
y relleno.
Los patrones de rellenos están 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 sólidos. El API 2D de Java proporciona
dos implementaciones adicionales para Paint, TexturePaint y GradientPaint.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
El TexturePaint define un
patrón de relleno utilizando un
simple fragmento de imagen
que se repite uniformemente.
El GradientPaint define un
relleno como un gradiente Figura 3 Relleno de gradiente y de textura
entre dos colores
Tomado de:
http://img.my.csdn.net/uploads/201206/13/1339601297_5930.jpg
En Java 2D, el renderizado de la línea exterior y el relleno de una figura son dos
operaciones separadas:
Usando el método draw se dibuja el contorno (línea exterior) de la figura usando el estilo
de lápiz especificado en el atributo Stroke y el patrón de relleno especificado por 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 están
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 método
draw.
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
están ocupando el área donde se está dibujando. El API 2D de Java encapsula reglas para
combinar los colores en el objeto Composite.
El API 2D de Java evita estos inconvenientes al implementar reglas de mezcla alfa (alpha-
blending) que tienen en cuenta la información acerca del modelo de color al hacer las
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
composiciones. El objeto alphaComposite incluye el modelo del color de los colores fuente
y destino.
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.
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 características del java.awt.image para
compatibilidad, y para mantener consistencia, las nuevas clases del modelo de color
también están localizadas en el paquete java.awt.image.
Antes de comenzar en serio con los componentes gráficos que proporciona el API 2D de
java, es necesario, hacer una pequeña revisión de la clase Graphics, superclase de
Graphics2D y revisar algunos conceptos básicos acerca del contexto gráfico, que
posteriormente permitirán comprender mucho mejor los ejemplos que se presentarán.
La clase Graphics es la clase base abstracta que proporciona toda, o al menos la mayoría,
de la funcionalidad para poder pintar tanto sobre componentes como sobre imágenes fuera
de pantalla.
Un objeto Graphics encapsula la siguiente información que será necesaria a la hora de las
operaciones básicas de pintado
Un objeto Graphics describe un contexto gráfico. Un contexto gráfico define una zona de
recorte, una zona a la que va a afectar; cualquier operación gráfica que se realice
modificará solamente los pixeles que se encuentren dentro de los límites 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 través de sus
múltiples métodos, intentando agruparlos por funcionalidad, que es lo que se ha intentado
aquí, aunque si el lector quiere una referencia completa y una descripción de los métodos
de esta clase deberá recurrir a la documentación 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 método getGraphics() sobre un componente. También se
puede recibir un objeto Graphics como parámetro cuando se van a sobreescribir los
métodos paint() o update().
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
En esta categoría estarían incluidos los métodos útiles en general, sin una asignación
específica de funcionalidad con respecto a acciones determinadas de dibujo. A
continuación, se enumeran algunos de los métodos considerados generales, para seguir
con la descripción y uso de algunos de ellos en aplicaciones de ejemplo.
create(), crea un nuevo objeto de tipo Graphics que es copia del objeto Graphics que ha
invocado al método.
finalice(), elimina el contexto gráfico cuando ya no hay ninguna referencia sobre él.
setColor( Color ), fija el color del contexto gráfico al color que se pasa como parámetro,
todas las operaciones gráfica siguientes que utilicen este contexto gráfico, utilizarán el
color que se especifica en este método.
setPaintMode(), fija la forma de pintar del contexto gráfico de modo que se sustituya lo
que había con lo nuevo. Cualquier operación de pintado sobreescribirá lo que hubiese en
la zona de destino con el color actual.
setXORMode( Color ), fija la forma de pintar del contexto gráfico 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 gráfico al punto que se pasa en los dos
parámetros en el sistema de coordenadas que se esté utilizando.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
La verdad es que se han escrito varias veces las palabras contexto gráfico, y no se ha
proporcionado al lector una explicación concreta de lo que significan estos términos. Hay
varias definiciones, para unos significa que la aplicación ha conseguido la habilidad para
pintar o colocar imágenes sobre un componente que tiene la característica de soportar el
pintado o visualización de imágenes. Otros autores prefieren decir que cada objeto
Graphics representa una determinada superficie de dibujo, luego ese objeto Graphics
define un contexto gráfico a través del cual se pueden manipular todas las actividades
gráficas sobre esa superficie. Y otros autores indican que un objeto Graphics es la superficie
última sobre la que se pueden colocar líneas, figuras y texto, por lo cual puede recibir
también el nombre de contexto gráfico al aunar información sobre la zona de dibujo, más
la fuente de caracteres, color y cualquier otro factor.
Ahora que ya se sabe lo que es un contexto gráfico, hay que ver cómo 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 código
de la aplicación, así que hay que recurrir a formas indirectas para conseguir el contexto
gráfico.
Uno de estos caminos indirectos para obtener un contexto gráfico es invocar el método
getGraphics() sobre otro objeto. Sin embargo, este método devuelve un contexto gráfico
de una imagen, es decir, que solamente funciona para objetos de tipo Image creados en
memoria a través del método createImage(), de la clase Component. Esta es una técnica
utilizada normalmente cuando se están usando imágenes 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 gráfico y, son sorprendentemente
simples, porque se hace automáticamente, y es cuando se sobreescriben los métodos
paint() y update(), en los cuales Java pasa como parámetro el contexto gráfico del objeto
al que pertenece el método.
Hay que tener en cuenta que el método repaint() pide al sistema que redibuje el
componente tan pronto como sea posible, pero esto lo hará el método update() que se
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
llame a continuación. No hay una relación uno a uno entre las llamadas a repaint() y
update(), por lo que es posible que múltiples llamadas a repaint() puedan recogerse en
una sola llamada a update().
En síntesis, el método paint() es el que ofrece el sistema para poder pintar lo que se quiera
sobre un determinado componente. En la clase base Component, este método no hace
absolutamente nada. Normalmente, en el caso de applets, se sobreescribe para hacer
presentar un rectángulo relleno con el color de fondo.
Veamos un primer ejemplo básico de obtención del contexto gráfico y pintado de una
cadena de texto en un objeto Frame en la siguiente figura. Notará que se utiliza la clase
Frame del AWT y no la JFrame del Swing, ya que se quieren asegurar la compatibilidad
Las clases del paquete java.awt.geom definen gráficos primitivos comunes, como puntos,
líneas, curvas, arcos, rectángulos y elipses.
Excepto para Point2D y Dimension2D, cada una de las otras clases geométricas
implementa el interfaz Shape, que proporciona un conjunto de métodos comunes para
describir e inspeccionar objetos geométricos bi-dimensionales.
Con estas clases podemos crear de forma virtual cualquier forma geométrica y dibujarla a
través de Graphics2D llamando al método draw o al método fill.
36.2 GeneralPath
La clase GeneralPath permite crear una curva arbitraria especificando una serie de
posiciones a lo largo de los límites de la forma.
El siguiente ejemplo muestra el uso de algunos de estos objetos gráficos y además de las
opciones para relleno y filete. El código original corresponde en un demo proporcionado en
el tutorial de Java 2D de la documentación del J2SE.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
/*
* Este es un ejemplo sobre el dibujo de Shapes, proporcionado por la
* documentación de Java en la versión 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 automáticamente 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;
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;
}
/* Toma las dimensiones del contexto y lo divide para saber el ancho y alto de
* cada una de las celdas de la cuadrícula donde dibujará
*/
Dimension d = getSize(); int gridWidth = d.width / 6; int gridHeight = d.height / 2;
int x = 5; int y = 7;
int rectWidth = gridWidth - 2*x;
int stringY = gridHeight - 3 - fontMetrics.getDescent();
int rectHeight = stringY - fontMetrics.getMaxAscent() - y - 2;
/* Asigna el filete, crea unos vectores con las coordenadas de los puntos del polígono,
* crea el objeto GeneralPath (polygon) trazando lineas entre las coordenadas
* y finalmente cierra el poligono. Dibuja el polígono 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);
/* Realiza los mismo pasos que para el polígono anterior, lo que varía es
* que en este caso no se cierra el polígono
*/
int x2Points[] = {x, x+rectWidth, x, x+rectWidth}; int y2Points[] = {y, y+rectHeight, y+rectHeight, y};
GeneralPath polyline = new GeneralPath(GeneralPath.WIND_EVEN_ODD, x2Points.length);
polyline.moveTo (x2Points[0], y2Points[0]);
for ( int index = 1; index < x2Points.length; index++ ) {
polyline.lineTo(x2Points[index], y2Points[index]);
};
g2.draw(polyline);
g2.drawString("GeneralPath (Abierto)", x, stringY); x += gridWidth;
/* Define los arreglos de las coordenadas para el polígono. Crea el polígono uniendo
* los puntos con líneas. Asigna el color rojo y dibuja el polígono relleno.
* Retorna el valor de la pintura a negro y dibuja el polígono mediante draw, lo
* que origina que se sibuje el filete del polígono.
*/
int x3Points[] = {x, x+rectWidth, x, x+rectWidth}; int y3Points[] = {y, y+rectHeight, y+rectHeight, y};
GeneralPath filledPolygon = new GeneralPath(GeneralPath.WIND_EVEN_ODD, x3Points.length);
filledPolygon.moveTo(x3Points[0], y3Points[0]);
for ( int index = 1; index < x3Points.length; index++ ) {
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);
}
La clase CubicCurve2D permite crear segmentos de curvas cúbicos. Una curva cúbica está
definida por dos puntos finales y dos puntos de control, los segmentos de curvas cúbicos
también se conocen como curvas de Bézier. Las siguientes figuras muestran ejemplos de
curvas cuadráticas y cúbicas.
El siguiente código crea una curva cuadrática con dos puntos finales y un punto de control.
Las posiciones de los puntos se seleccionan con respecto al tamaño de la ventana.
//Crea los objetos que definen los puntos de inicio, final y control
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
//Dibuja la curva
g2.draw(quad);
Lección 37 Áreas
Con la clase Area se pueden realizar operaciones boolenas, como uniones, intersecciones
y substracciones, sobre dos objetos Shape cualquiera. Esta técnica, permite crear
rápidamente objetos Shape complejos sin tener que describir cada línea de segmento o
cada curva, este proceso se denomina construir un área geométrica (CAG). Una Area
soporta las siguientes operaciones booleanas.
unión Sustracción
En el siguiente ejemplo, tomado del tutorial de gráficos del sitio web de Programación en
castellano, se crea un Area que dibuja una pera a partir de objetos elipses y operaciones
de unión, sustracción e intersección. La ejecución proporciona la siguiente ventana gráfica.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.applet.*;
import javax.swing.*;
/*
* Este applet dibuja una pera, usando métodos de Constructive Area Geometry (CSG)
* para adición, sustracción e intersección.
*/
public class Pera extends Applet {
Ellipse2D.Double circle, oval, leaf, stem;
Area circ, ov, leaf1, leaf2, st1, st2;
/* Crea el pedazo de tronco a partir del llenado del Area resultante de la sustracción de
* dos objetos Area creados a partir de una elipse.
*/
stem.setFrame(ew, eh-42, 40.0, 40.0);
st1 = new Area(stem);
stem.setFrame(ew+3, eh-47, 50.0, 50.0);
st2 = new Area(stem);
st1.subtract(st2); g2.fill(st1);
g2.setColor(Color.yellow);
g2.fill(circ);
}
Es posible mostrar una cadena de texto con cualquier tipo de letra disponible en el sistema,
en cualquier tamaño y en el estilo que se seleccione. Para determinar las fuentes que están
disponibles en el sistema es necesario llamar el método
GrpahicsEnvironment.getAvailableFontFamilyNames. Este método retorna un arreglo de
cadenas que contiene los nombres de las familias de las fuentes disponibles, cualquiera de
estas cadenas, además del tamaño y el estilo, pueden ser utilizados como argumentos
para crear un nuevo objeto Font.
Para construir el ejemplo, es necesario utilizar el siguiente código 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:
A continuación, se crea un objeto Font con un estilo Font.PLAIN y un tamaño de 10. Los
otros estilos disponibles son ITALIC, BOLD y BOLD+ITALIC.
Font thisFont;
...
thisFont = new Font("Arial", Font.PLAIN, 10);
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
envían pasando un objeto Font al método 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 envía al contexto Graphics 2D en el metodo Paint() para que sean
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
g2.setFont(thisFont);
String cadena = "Seleccione una fuente, tamaño y estilo para modificarme";
FontMetrics medida = g2.getFontMetrics();
int ancho = medida.stringWidth( cadena );
int alto = medida.getHeight();
/*
* Ejemplo de selección de fuentes. Construido para el Tutorial
* de Java2D de Sun Microsystems.
*/
import java.lang.Integer;
import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Vector;
cmbFuente.addItemListener(this);
nuevafuente = envcmbFuente[0];
pnlLetra.add(cmbFuente);
/*Se asignan los valores para el combo de tamaño, los posibles tamaños serán 10,
*12,14,16,18. Se define como máximo número 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);
nuevotam = (String)cmbTamano.getSelectedItem();
}
//Cambia la fuente del contexto, de acuerdo con los nuevos atributos seleccionados en los combo
fontC.cambiarFuente(nuevafuente, nuevoestilo, nuevotam);
}
// Este método es el que modifica la fuente de acuerdo con los nuevos parámetros
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();
}
Se recomienda revisar el ejemplo y plantear una solución para cuando el texto no cabe en
una línea y se requiere separarlo, como en el caso de un párrafo.
Lección 39 Imágenes
BufferedImage es la clase clave del API del modo-inmediato. Esta clase maneja una imagen
en memoria y proporciona métodos 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 búfer de datos
accesible. Un
BufferedImage tiene un
ColorModel y un Ráster de Figura 12 Clase BufferedImage (Sun Microsystems)
El API Java 2D define varias operaciones de filtrado para objetos BufferedImage. Cada
operación de proceso de imágenes está incluida en una clase que implementa la interfaz
BufferedImageOp. La manipulación de imágenes se realiza en el método filter. La clase
BufferedImageOp en el API Java 2D soporta:
• Transformación afin
• Escalado
• Modificación de Aspecto
• Combinación Linear de Bandas
• Conversión de color
• Convolución.
Para filtrar un BufferedImage usando una de las clases de operación de imagense debe:
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 ejecución es la pantalla que se muestra en la Figura 13.
Para construir y aplicar este tipo de filtrado al BufferedImage, este ejemplo usa un código
similar al del siguiente fragmento.
El código completo de la aplicación, que contiene los cuatro filtros aplicados a las imágenes
es el siguiente:
/*
* Ejemplo de aplicación de filtros utilizando BufferedImage y BufferedImageOp.
* Versión modificada del ejemplo del Tutorial de Java 2D de Sun Microsystems.
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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};
public void init() {
setBackground(Color.white);
//Tamaño del applet para calcular los tamaños 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};
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);
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
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 el texto
TextLayout texto = new TextLayout(Descrip[i], g2.getFont(),g2.getFontRenderContext());
texto.draw(g2, (float) x, (float) y-4);
}
}
f.getContentPane().add("Center", elapplet);
elapplet.init();
f.pack();
f.setSize(new Dimension(610,450));
f.show();
}
}
Un BufferedImage puede usarse fácilmente como un búfer fuera de pantalla. Para crear un
BufferedImage cuyo espacio, color, profundidad y distribución de pixeles
El siguiente ejemplo permite al usuario arrastrar un rectángulo sobre la ventana del applet.
En lugar de dibujar el rectángulo en cada posición del cursor, para proporcionar información
al usuario, se usa un BufferedImage como búfer fuera de la pantalla. Cuando se arrastra
el rectángulo, es renderizado dentro del BufferedImage en cada nueva posición y el
BufferedImage se copia en la pantalla. El ejemplo fue tomado del Tutorial de Sun
Microsystems además de ilustrar el uso del doble búfer le puede servir para ilustrar un
posible proceso de animación. Lea atentamente el código comentado.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import java.awt.image.*;
f.show();
}
}
/* 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;
r = new Rectangle(0,0,5,5);
// Maneja el evento cuando el usuario arrastra el mouse miesntras mantiene presionado el botón.
public void mouseDragged(MouseEvent e){
if(!estaFuera){
updateLocation(e);
}
else {
BufferedShapeMover.lblTexto.setText("Posicione el cursor en el rectángulo y luego arrastre");
}
}
if(primeraVez){
Dimension dim = getSize();
int ancho = dim.width;
int alto = dim.height;
area = new Rectangle(dim);
bi = (BufferedImage)createImage(ancho, alto);
contexto = bi.createGraphics();
rect.setLocation(ancho/2-50, alto/2-25);
contexto.setStroke(new BasicStroke(10.0f));
primeraVez = false;
}
contexto.fill(rect);
if((rect.x+100)>area.width){
nuevo_x = area.width-99;
}
if((rect.y+50)>area.height){
nuevo_y = area.height-49;
}
El API Java 3D es una interface para escribir programas que muestran e interactúan con
gráficos tridimensionales. Java 3D es una extensión estándar del JDK 2 de Java. El API
Java 3D proporciona una colección de constructores de alto-nivel para crear y manipular
geometrías 3D y estructuras para dibujar esta geometría. Java 3D proporciona las
funciones para creación de imágenes, visualizaciones, animaciones y programas de
aplicaciones gráficas 3D interactivas.
El API 3D de Java es un árbol de clases Java que sirven como interfaz para sistemas de
renderizado de gráficos tridimensionales y un sistema de sonido. El programador trabaja
con constructores de alto nivel para crear y manipular objetos geométricos en 3D. Estos
objetos geométricos residen en un universo virtual, que luego es renderizado. El API está
diseñado con flexibilidad para crear universos virtuales precisos de una ámplia variedad de
tamaños, desde astronómicos a subatómicos.
A pesar de toda esta funcionalidad, el API es sencillo de usar. Los detalles de renderizado
se manejan automáticamente. Aprovechándose de los Threads Java, el renderizador Java
3D es capaz de renderizar en paralelo. El renderizador también puede optimizarse
automáticamente para mejorar el rendimiento del renderizado.
Un programa Java 3D crea ejemplares de objetos Java 3D y los sitúa en una estructura de
datos de escenario gráfico. Este escenario gráfico es una composición de objetos 3D en
una estructura de árbol que especifica completamente el contenido de un universo virtual,
y cómo 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
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Todo programa Java 3D está, al menos parcialmente, ensamblado por objetos del árbol de
clases Java 3D. Esta colección 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 métodos en las clases del API Java 3D. Sin embargo, un sencillo
universo virtual que incluya animación puede construirse con unas pocas clases. Esta
sección describe un conjunto mínimo de objetos y sus interacciones para renderizar un
universo virtual.
Esta sección 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 programación Java 3D.
Además del paquete corazón 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 corazón incluye
sólo las clases de menor nivel necesarias en la programación Java 3D.
Las clases de utilidades son adiciones convenientes y poderosas al corazón. Estas clases
se dividen en cuatro categorías: cargadores de contenidos, ayudas a la construcción del
escenario gráfico, clases de geometría y utilidades de conveniencia.
En el resto del texto, el término objeto visual se utilizará para hacer referencia a un "objeto
del escenario gráfico" (por ejemplo, un cubo o una esfera). El término objeto sólo se usará
para referirse a un ejemplar de una clase. El término contenido se usará para referirnos a
objetos visuales en un escenario gráfico como un todo.
La relación más común es padre-hijo. Un nodo Group puede tener cualquier número de
hijos, pero sólo un padre. Un nodo hoja sólo puede tener un padre y no puede tener hijos.
La otra relación es una referencia. Una referencia asocia un objeto NodeComponent con
un nodo del escenario gráfico. Los objetos NodeComponent definen la geometría y los
atributos de apariencia usados para renderizar los objetos visuales.
Un escenario gráfico Java 3D está construido de objetos nodos con relaciones padre-hijo
formando una estructura de árbol. En una estructura de árbol, un nodo es la raíz. Se puede
acceder a otros nodos siguiendo los arcos desde la raíz. Los nodos de un árbol no forman
bucles. Un escenario gráfico está formado desde los árboles con raíces en los objetos
Locale. Los NodeComponents y las referencias a arcos no forman parte del escenario
gráfico.
Sólo existe un camino desde la raíz de un árbol a cada una de las hojas; por lo tanto, sólo
hay un camino desde la raíz hasta el escenario gráfico de cada nodo hoja. El camino desde
la raíz de un escenario gráfico hasta una hoja especificada es el camino al escenario gráfico
del nodo hoja. Como un camino de un escenario gráfico trata exactamente con una sola
hoja, hay un camino de escenario gráfico para cada hoja en el escenario.
Para diseñar un universo virtual Java 3D se dibuja un escenario gráfico usando un conjunto
de símbolos estándar. Después de completar el diseño, este escenario gráfico es la
especificación para el programa. Después de completar el programa, el mismo escenario
gráfico es una representación concisa del programa (asumiendo que se siguió la
especificación)
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Cada uno de los símbolos mostrados al lado izquierdo de la Figura 15 representa un sólo
objeto cuando se usa en un escenario gráfico. Los dos primeros símbolos representan
objetos de clases específicas: VirtualUniverse y Locale. Lo siguientes tres símbolos de la
izquierda representan objetos de las clases Group, Leaf, y NodeComponent. Estos tres
símbolos normalmente tienen anotaciones para indicar la subclase del objeto específico. El
último símbolo se usa para representar otras clases de objetos.
El símbolo de la flecha sólida representa una relación 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 gráfico. En la Figura 16, se puede
observar un sencillo escenario gráfico.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Tomadode: http://programacion.net/cursos_descargas/3d/images/java3d_2.gif
Es posible crear un escenario gráfico ilegal. Se puede ver uno en la Figura 17. 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 sólo puede tener un padre. En otras palabras, sólo puede haber un camino desde el
objeto Locale hasta la hoja (o un camino desde la hoja hasta el objeto Locale).
Es posible pensar que la estructura mostrada en la Figura 17 define tres objetos visuales
en un universo virtual. Pero el escenario gráfico 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 podría situar una
imagen en el objeto visual en diferentes localizaciones. Sin embargo, es un escenario
gráfico ilegal porque el arco padre- hijo no forma un árbol. En este ejemplo, el resultado
es que el objeto Shape3D tiene más de un padre.
Las explicaciones del árbol y de las estructuras DAG son correctas. Sin embargo, el sistema
de ejecución Java 3D reporta el error en términos de la relación hijo- padre. Un resultado
de la limitación de la estructura de árbol es que cada objeto Shape3D está limitado a un
sólo padre. Para el ejemplo de la Figura 17, se lanzará una excepción 'multiple parent' en
el momento de la ejecución. La Figura 18, con un padre para cada objeto Shape3D,
muestra una posible solución para este escenario gráfico.
Es posible pensar que la estructura mostrada en la Figura 18 define tres objetos visuales
en un universo virtual. Pero el escenario gráfico 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 podría situar una
imagen en el objeto visual en diferentes localizaciones. Sin embargo, es un escenario
gráfico ilegal porque el arco padre- hijo no forma un árbol. En este ejemplo, el resultado
es que el objeto Shape3D tiene más de un padre.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Las explicaciones del árbol y de las estructuras DAG son correctas. Sin embargo, el sistema
de ejecución Java 3D reporta el error en términos de la relación hijo- padre. Un resultado
de la limitación de la estructura de árbol es que cada objeto Shape3D está limitado a un
sólo padre. Para el ejemplo de la Figura 18, se lanzará una excepción 'multiple parent' en
el momento de la ejecución. La Figura 19, con un padre para cada objeto Shape3D,
muestra una posible solución para este escenario gráfico.
Cada escenario gráfico tiene un sólo 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 localización
de los objetos visuales en el universo virtual.
En la Figura 20 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.
mayoría de los objetos de un escenario gráfico. 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 métodos importantes de sus subclases. Las subclases de Node componen
escenarios gráficos.
Clase Group
Clase Leaf
Clase NodeComponent
Las subclases de SceneGraphObject son los ladrillos que se ensamblan en los escenarios
gráficos. La línea básica de desarrollo de un programa Java 3D consiste en siete pasos (a
los que la especificación del API Java 3D se referiere como un Receta) presentados a
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
continuación. Esta receta puede usarse para ensamblar muchos programas útiles de Java
3D.
Esta receta ignora algunos detalles, pero ilustra el concepto fundamental para toda la
programación Java 3D: crear la rama gráfica del escenario gráfico es la programación
principal. En vez de ampliar esta receta, los siguientes párrafos explican una forma sencilla
de construir un escenario gráfico muy similar con menos programación.
Los programas Java 3D escritos usando la receta básica tienen ramas de vista gráfica con
idéntica estructura. La regularidad de la estructura de las ramas de vista gráfica tambien
se encuentra en la clase de utilidad SimpleUniverse. Los ejemplares de esta clase realizan
los pasos 2, 3 y 4 de la receta básica. Usando la clase SimpleUniverse en programación
Java 3D se reduce significativamente el tiempo y el esfuerzo necesario para crear las ramas
de vista gráfica. Consecuentemente, el programador tiene más tiempo para concentrarse
en el contenido. Esto es de lo que se trata el escribir programas Java 3D.
La clase SimpleUniverse
clases corazón usadas para crear una rama de vista gráfica. Observe que SimpleUniverse
sólo usa indirectamente los objetos View y ViewPlatform del corazón Java 3D. Los objetos
SimpleUniverse suministran la funcionalidad de todos los objetos que hay dentro del
recuadro azul de la Figura 21.
Figura 21 Universo virtual mínimo proporcionado por la clase SimpleUniverse (en azul)
Constructores de SimpleUniverse
Paquete: com.sun.j3d.utils.universe
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Esta clase configura un entorno de usuario mínimo para obtener rápida y fácilmente un
programa Java 3D y ejecutarlo.
Esta clase de utilidad crea todos los objetos necesarios para la rama de vista gráfica.
Especificamente crea los objetos Locale, VirtualUniverse, ViewingPlatform, y Viewer (todos
con sus valores por defecto). Los objetos tienen las relaciones apropiadas para formar la
rama de vista gráfica.
El objeto SimpleUniverse crea una rama de vista gráfica completa para un universo virtual.
Esta rama incluye un plato de imagen. Un plato de imagen es el rectángulo 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 22 muestra la relación entre el plato de imagen, la posición del ojo, y el universo
virtual. La posición del ojo está detrás 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 proyección de los objetos visuales sobre el plato de imagen. Esta idea se ilustra
con los cuatro proyectores de la imagen (líneas punteadas).
Los típicos programas Java 3D mueven la vista hacía atrás (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 método
setNominalViewingTransform que selecciona la posición del ojo para que esté centrado en
(0, 0, 2.41) buscando en dirección z negativa hacia el origen.
Paquete: com.sun.j3d.utils.universe
void setNominalViewingTransform()
Después de crear la rama de contenido gráfico, se inserta dentro del universo usando el
método addBranchGraph de SimpleUniverse. Este método toma un ejemplar de
BranchGroup como único argumento. Este BranchGroup se añade como hijo del objeto
Locale creado por SimpleUniverse.
Insertar una rama gráfica dentro de un Locale la hace viva, y consecuentemente, cada
uno de los objetos de esa rama gráfica también están vivos. Hay algunas consecuencias
cuando un objeto se convierte en vivo. Los objetos vivos estan sujetos a
renderización. Los parámetros 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.
while(true) {
Procesos de entrada
If (petición de salida) break
Realiza comportamientos
Atraviesa el escenario gráfico
y renderiza los objetos visuales
}
Limpieza y salida
Las secciones anteriores explicaban la construcción de un sencillo universo virtual sin una
rama de contenido gráfico. La creación de esta rama es el objetivo de las siguientes
secciones.
El programa Java 3D típico 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 podrían escribirse como aplicaciones, pero usar applets ofrece una
forma más sencilla de producir una aplicación con ventanas.
El paso 3 de esta sencilla receta es crear la rama de contenido gráfico. Esta rama se crea
en el fragmento de código que se muestra en la Figura 24
La clase HelloJava3Da está derivada de Applet pero el programa puede ejecutarse como
una aplicación con el uso de la clase MainFrame. La clase Applet se usa como clase base
para hacer más fácil 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 aplicación.
El tamaño de la ventana de la
aplicación resultante se
especifica en la construcción Figura 25 Método main que crea la ventana invocando
de la clase MainFrame Tomado de: Autoria propia
Los tres fragmentos de código anteriores (Figura 23, Figura 24 y Figura 78) forman un
programa Java 3D completo cuando se usan las sentencias import adecuadas. A
continuación, se pueden ver las sentencias import necesarias para compilar la clase
HelloJava3Da. Las clases más comunmente usadas en Java 3D se encuentran en los
paquetes javax.media.j3d, o javax.vecmath.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
La imagen que proporciona la ejecución del código completo se muestra en la Figura 28.
Como no se explica cada línea de código del ejemplo HelloJava3Da, las ideas básicas de
ensamblar un programa Java 3D deberían estar claras habiendo leído el ejemplo. La
siguiente sección presenta cada una de las clases usadas en el programa.
Para añadir un poco de entendimiento del API Java 3D y el ejemplo HelloJava3Da aquí se
presenta una síntesis de las clases del API Java 3D usadas en HelloJava3Da.
Clase BranchGroup
Los objetos de este tipo se usan para formar escenarios gráficos. Los ejemplares de
BranchGroup son la raíz de los sub-gráficos. 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.
BranchGroup() Los ejemplares de BranchGroup sirven como raíz para las ramas
del escenario gráfico; 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 gráfica del escenario gráfico.
Clase Transform3D
Clase TransformGroup
Clase Vector3f
Clase ColorCube
ColorCube() Construye un cubo de color del tamaño 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
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Una simple rotación del cubo puede hacer que se vea más de una de sus caras. El primer
paso es crear la transformación deseada usando un objeto Transform3D.
El eje se elige seleccionando el método apropiado (rotX, rotY o rotZ). El ángulo de rotación
es el valor que se le pasa como argumento. Como el ángulo de rotación se especifica en
radianes, el valor PI/4 es 1/8 de una rotación completa, o 45 grados. Solamente las líneas
24 y 27 ejecutan la rotación en un eje.
Tomado de:
http://programacion.net/cursos_descargas/3d/i
mages/java3d_10.gif
Figura 31 Resultado de rotar el cubo en X Figura 32 Resultado de rotar el cubo en Y Figura 33 Resultado de rotar el cubo en Z
Para crear estas dos rotaciones simultáneas se requiere combinar dos objetos Transform3D
de rotación. El ejemplo rota el cubo sobre los ejes x e y. Se crean dos objetos Transform3D,
uno por cada rotación (líneas 24 y 25). Las rotaciones individuales se especifican para los
dos objetos TransformGroup (líneas 27 y 28). Luego las rotaciones se combinan mediante
la multiplicación de los objetos Transform3D (línea 29). La combinación de las dos
transformaciones se carga en el objeto TransformGroup (línea 31).
rotate.rotX(Math.PI/4.0d);
tempRotate.rotY(Math.PI/5.0d);
rotate.mul(tempRotate);
simpleU.addBranchGraph(scene);
} // Fin del constructor HelloJava3Db
El escenario gráfico construido por un programa Java 3D podría usarse directamente para
renderizar. Sin embargo, la representación no es muy eficiente. La flexibilidad construida
dentro de cada objeto escenario gráfico (que no se van a discutir en este tutorial) crean
una representación sub-optima del universo virtual. Para mejorar el rendimiento de la
renderización se usa una representación más eficiente del universo virtual.
Java 3D tiene una representación interna para un universo virtual y los métodos para hacer
la conversión. Hay dos formas para hacer que el sistema Java 3D haga la conversión de la
representación interna. Una forma es compilar todas las ramas gráficas. La otra forma es
insertar una rama gráfica en un universo virtual para darle vida.
Compilar Contenidos
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 gráfico. Por ejemplo, si un escenario gráfico
tiene dos objetos TransformGroup en una relación padre-hijo pueden ser representados
por un objeto TransformGroup. Otra posibilidad es combinar objetos Shape3D que tienen
una relación estática física. Estos tipos de optimizaciones se hacen posibles cuando las
capacidades no se configuran.
Capacidades
Una vez que una rama gráfica empieza a vivir o es compilada el sistema de renderizado
Java 3D la convierte a una representación interna más eficiente. El efecto más importante
de esta conversión es la mejora del rendimiento de renderizado.
Pero también tiene otros efectos, uno de ellos es fijar el valor de transformaciones y otros
objetos en el escenario gráfico. A menos que especificamente se le proporcionen al
programa, este no tendrá la capacidad de cambiar los valores de los objetos del escenario
gráfico una vez que estén vivos.
Hay casos en que un programa necesita la capacidad de cambiar estos valores después de
que estén vivos. Por ejemplo, cambiar el valor de un objeto TransformGroup crea
animaciones. Para que esto suceda, la transforamción debe poder cambiar después de
estar viva. La lista de parámetros a los que se puede acceder, y de qué 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 después de compilarlo o de darle vida.
El conjunto de capacidades varía con la clase. SceneGraphObject es la superclase de casi
cualquier clase usada para crear un escenario gráfico, incluyendo Group, Leaf, y
NodeComponent.
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 automáticamente la
posición, la orientación, el color, u otros atributos del objeto visual.
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, añade el objeto visual al escenario gráfico y hace las referencias
apropiadas entre los objetos del escenario gráfico y los objetos Behavior.
La siguiente lista enumera los pasos que se requieren para especificar una animación con
un objeto Interpolator. Los siguientes pasos forman una receta para crear un
comportamiento de animación con interpolación:
El fragmento de código de la Figura 37 muestra un ejemplo completo del uso de las clases
interpoladoras para crear una animación. La animación creada con este código es una
rotación continúa con un tiempo de rotación total de 4 segundos.
El paso 2 es crear un objeto Alpha para dirigir la interpolación. Los dos parámetros
especificados en la línea 34 del fragmento de código son el número de interacciones del
bucle y el tiempo de un ciclo. El valor de "-1" especifica un bucle contínuo. 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.
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Este fragmento de código se usa con otros fragmentos anteriores para crear el programa
de ejemplo HelloJava3Dc.java. Al ejecutar la aplicación veremos cómo se renderiza el
ColorCube con un comportamiento de rotación cada cuatro segundos.
El programa HelloJava3Dc
crea el escenario gráfico de
la Figura 38. El objeto
rotation es tanto hijo del
TransformGroup como una
referencia a él. Aunque esta
relación parece violar las
restricciones de bucles
dentro del escenaio gráfico,
no lo hace. Recuerda que los
Figura 38 Escenario gráfico incluyendo comportamiento
arcos de referencia (flecha
Tomado de: punteada) no son parte del
http://programacion.net/cursos_descargas/3d/images/java3d_14.gif escenario gráfico. La línea
Clase RotationInterpolator
Mapear una acción en el tiempo se hace usando un objeto Alpha. La especificación de este
objeto puede ser compleja.
Clase Alpha
Los objetos de la clase Alpha se usan para crear una función que varía 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 parámetros del objeto Alpha. Los objetos Alpha se usan comúnmente
con un comportamiento Interpolator para proporcionar animaciones de objetos visuales.
Alpha tiene diez parámetros, haciendo la programación tremendamente flexible. Sin entrar
en detalles de cada parámetro, saber que un ejemplar de Alpha puede combinarse
fácilmente con un comportamiento para proporcionar rotaciones sencillas, movimientos de
péndulo, 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 función de tiempo que genera valores alpha
entre cero y uno. La función "f(t)" y las características del objeto Alpha están determinadas
por parámetros definidos por el usuario:
Región Programada
Hay varias formas de especificar una región programada, la más sencilla es crear un objeto
BoundingSphere. Otras opciones incluyen BoundingBox y BoundingPolytope.
Clase BoundingSphere
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.event.*;
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.*;
RotationInterpolator rotator =
new RotationInterpolator(rotationAlpha,
objSpin, yAxis,
0.0f, (float) Math.PI*2.0f);
return objRoot;
} // Fin del método CreateSceneGraph
public HelloJava3Dd() {
setLayout(new BorderLayout());
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
Figura 40 Escena gráfica que combina transformación y Figura 41 Ejecución del ejemplo HelloJava3Dd.java
comportamiento
Tomado de:
Tomado de: http://programacion.net/cursos_descargas/3d/imag
http://programacion.net/cursos_descargas/3d/imag es/java3d_17.gif
es/java3d_14.gif
Universidad Nacional Abierta y a Distancia – UNAD
Vicerrectoría Académica y de Investigación - VIACI
Escuela: Escuela De Ciencias Básicas Tecnología E Ingeniería Programa: Ingeniería de Sistemas
Curso: Computación Gráfica Código: 299210
Referencias Bibliográficas
Foley, J., Van Dam, A., Feiner, S., & Huges, J. (1996). Computer graphics: principles and
practice. Addison Wesley.
fukinotou11d. (2015). 3D Models in Java 3D: Beginners Only_1 Color Cube and
Coordinate Systems (with Source Code). Obtenido de
https://www.youtube.com/watch?v=bAA6NRW3D4s