6. Extensiones

A partir de JDK 1.2 se incorpora un mecanismo de extensiones que permite añadir nuevas funcionalidades al núcleo de la plataforma Java. Existen extensiones desarrolladas por Sun, como Java 3D y Javamail, pero además cualquier usuario puede desarrollar sus propias extensiones.

6.1. Mecanismo de extensiones de Java

El mecanismo de extensiones proporciona escalabilidad a Java, permitiendo hacer que nuestra propia API esté disponible para cualquier aplicación.

Las extensiones son grupos de paquetes y clases que añaden funcionalidades a la plataforma Java, y que serán incluidas mediante el mecanismo de extensiones de Java. Este mecanismo permite que las extensiones definidas sean accesibles por cualquier aplicación sin necesidad de establecer el CLASSPATH, como si se tratase de las clases del núcleo de Java. De hecho, estas extensiones lo que hacen es extender la API del núcleo.

Gracias a este mecanismo podremos obtener e instalar extensiones que amplíen la API del núcleo de la plataforma Java, bien sean extensiones desarrolladas por Sun o por terceros, o bien crear nuestras propias extensiones. Esto nos permitirá ampliar la API según nuestras necesidades, y además facilitará la distribución de nuestras propias librerías de clases, que cualquier usuario podrá instalar y utilizar fácilmente sin preocuparse del lugar donde ubicar las clases y de establecer las variables de entorno necesarias.

Para la creación de nuestras propias extensiones necesitaremos empaquetar todas las clases de nuestra extensión en un fichero JAR, por lo que a continuación veremos como trabajar con este tipo de ficheros.

6.2. Ficheros JAR

A parte de permitirnos crear extensiones de Java, los ficheros JAR tienen varias ventajas:

• Seguridad: Los ficheros JAR pueden estar firmados digitalmente, de forma que cuando el usuario confíe en la firma podrá otorgar permisos a la aplicación.
• Descarga: Al estar contenidas todas las clases en un único fichero el tiempo de descarga disminuye, ya que no necesita establecer una conexión por cada fichero por separado. Además es posible comprimir el contenido del fichero JAR siendo esto totalmente transparente a la hora de usar las clases contenidas en él.
• Versiones: Los ficheros JAR permiten incluir información sobre la versión. Además podemos sellar los paquetes contenidos en el fichero JAR, de forma que todo el contenido del paquete deberá estar dentro del fichero JAR, asegurando así la consistencia en las versiones.
• Portabilidad: Al ser el mecanismo de los ficheros JAR un estándar de la plataforma Java estos ficheros serán portable a cualquier sistema que cuente con Java.

Los ficheros JAR utilizan el formato ZIP, por lo que podremos abrirlos con cualquier aplicación que trabaje con ficheros ZIP. De todas formas Java incorpora una herramienta para trabajar con estos ficheros JAR, llamada jar. Con ella podremos empaquetar o extraer el contenido de un fichero JAR, y realizar otras operaciones propias de este formato. Para empaquetar una serie de ficheros de entrada en un JAR haremos lo siguiente:

jar cvf fichero_jar ficheros_de_entrada

Ahora podemos visualizar el contenido de nuestro fichero JAR cambiando el parámetro de la acción a realizar por t.

jar tf fichero_jar

Si hacemos esto veremos que además de los ficheros especificados dentro del JAR de ha incluido el fichero META-INF/MANIFEST.MF. Este fichero de manifiesto está incluido en todos los JAR, y contiene información sobre su contenido.

Podemos ahora extraer todo el contenido del JAR cambiando el comando de acción por x.

jar xvf fichero_jar

Con esto se extraerán todos los ficheros, incluido el manifiesto, pudiendo así editar dicho fichero con cualquier editor ASCII. En este caso veremos el manifiesto por defecto que se incluye en los ficheros JAR. Podemos añadir líneas al manifiesto , para ello deberemos crear un fichero con la información que queramos añadir, e incluirlo al crear el JAR para que a la líneas por defecto, añada los datos que nosotros hayamos incluido. Esto lo haremos con:

jar cmf fichero_manifiesto fichero_jar ficheros_de_entrada

Una vez tengamos nuestras clases empaquetadas en un fichero JAR, para utilizarlas bastará con tener incluido el fichero JAR en el CLASSPATH. De esta forma las clases serás accesibles de la misma forma que si estuviesen directamente en el CLASSPATH sin empaquetar. Para añadir un fichero JAR al CLASSPATH tendremos que incluir el fichero JAR con su ruta absoluta en esta variable de entorno:

SET CLASSPATH=%CLASSPATH%;c:\ruta\fichero.jar

También podemos indicar el CLASSPATH del fichero JAR directamente en la línea de comandos al ejecutar nuestra aplicación ClasePrincipal:

java -cp c:\ruta\fichero.jar ClasePrincipal

En el caso de que empaquetemos una aplicación, podremos definir una clase principal de forma que el fichero JAR sea autoejecutable simplemente escribiendo:

java -jar fichero_jar

Además, en Windows al hacer doble click sobre este fichero JAR también se ejecutará, ya que este tipo de ficheros estarán asociados con el intérprete Java. Para hacer este JAR ejecutable deberemos definir cuál es la clase principal que se va a ejecutar, cosa que haremos en el fichero manifiesto. Para ello deberemos incluir un fichero manifiesto que añada la línea:

Main-Class: MiClasePrincipal

En el caso de los Applets, para cargar un Applet desde un JAR deberemos especificar el fichero JAR en el atributo ARCHIVE del tag APPLET, como se muestra a continuación:

<applet code=MiApplet.class
		archive="AppletJAR.jar">
</applet>

Lo primero que deberemos hacer cuando queramos crear un extensión es seleccionar todos los paquetes y clases que formarán parte de la API de nuestra extensión y empaquetarlos en un único fichero JAR.

Una vez tengamos el fichero JAR, deberemos añadirlo como extensión, teniendo dos alternativas para ello:
 

• Incluir el JAR en el directorio de extensiones, con lo que la plataforma localizará el fichero en el directorio e incluirá la API contenida en él al núcleo de Java. Esta será una extensión instalada.
• Otra posibilidad es hacer referencia al fichero JAR desde un manifiesto , en este caso será una extensión descargada.

En el caso de las extensiones instaladas, deberemos copiar el JAR dentro del directorio del JRE (Java Runtime Environment), en el subdirectorio lib/ext. JDK incluye JRE como un subdirectorio suyo, por lo que en este caso la ruta completa donde habrá que incluir los JAR será:

{java.home}/jre/lib/ext/

Con esto la extensión se habrá incluido en la plataforma Java instalada en nuestra máquina, permitiendo que cualquier programa Java que se ejecute en ella pueda utilizarla directamente.

Sin embargo, pensemos en el caso de un Applet que necesita utilizar una determinada extensión. En este caso no podemos suponer que cualquiera que visite dicho Applet va a tener instalada la extensión necesaria. En este caso será más apropiado utilizar extensiones descargadas. Para utilizar una extensión descargada, deberemos incluir en el manifiesto del JAR que contiene el Applet la siguiente línea:

Class-Path: fichero_jar

De esta forma sabrá que para ejecutar el Applet deberá descargar la extensión especificada en esta línea.

Para la carga de clases, Java buscará en el siguiente orden:

1. Clases principales de Java (rt.jar, i18n.jar).
2. Extensiones instaladas
3. Classpath

En la página de Sun podemos encontrar una larga lista de extensiones de Java desarrolladas por ellos, que podremos descargar e instalar ampliando de esta manera la API de Java. A continuación veremos las principales extensiones disponibles y una descripción de cada una de ellas:

• Java Communications: Esta API puede ser utilizada para hacer aplicaciones de comunicaciones (voz, fax, etc) independientes de la plataforma. Nos permitirá el acceso a los puertos serie y paralelo.
• Javamail: Proporciona una serie de clases que permitirán construir nuestro propio sistema de correo y mensajería utilizando tecnología Java. Incorpora un proveedor de servicio POP3.
• Java 3D: Nos permitirá incluir de forma sencilla e independiente de la plataforma gráficos 3D en nuestras aplicaciones. Incorpora una sencilla interfaz de alto nivel que nos permitirá definir mundos 3D y controlar el render y la conducta de los objetos 3D.
• Java Media Framework: Permite incorporar a nuestras aplicaciones y Applets elementos multimedia, como puede ser audio y video. Con esta API podremos reproducir, capturar y trabajar con flujos (streaming) de varios tipos de medios.
• Java Advanced Imaging: Esta API proporciona funcionalidades para el procesamiento de imágenes con un alto rendimiento, de forma independiente a la plataforma. Proporciona una interfaz orientada a objetos que permite manipular imágenes de forma sencilla.
• JavaBeans Activation Framework: Permite averiguar el tipo de unos datos determinados (por ejemplo una imagen), encapsular el acceso a estos datos y averiguar las operaciones que podemos hacer con ellos, pudiendo instanciar el bean correspondiente para realizar estas operaciones.
• Infobus: Permite la comunicación entre JavaBeans, definiendo una serie de interfaces entre los beans que colaboran y un protocolo de comunicaciones para estas interfaces.
• Java Cryptography Extension: Consiste en una serie de paquetes que proporcionan funcionalidades de encriptación y generación de claves.
• JavaHelp: Permite a los desarrolladores incorporar ayuda en línea a los programas que realicen, de forma independiente de la plataforma.

6.5. Java 3D y JAI

6.5.1. Java 3D

Introducción

Java 3D es una extensión de Java utilizada para desarrollar aplicaciones que incorporen gráficos tridimensionales . Se construyen con ella objetos geométricos y se colocan en un universo virtual, que luego es renderizado.

Los objetos de un programa Java 3D se colocan en una estructura de tipo árbol, llamada grafo de escena, que define un universo virtual:

Figura 1. Grafo de escena en Java 3D

El grafo tiene como raíz un universo virtual (VirtualUniverse o SimpleUniverse) . El Locale define un sistema de coordenadas. De este objeto parten nodos de grupo ( BranchGroup ), que nos definen un subgrafo. Los nodos de transformación (TransformGroup) permiten aplicar transformaciones ( Transform3D ) a sus hijos. Los nodos hojas serán los objetos 3D. Podrán ser formas geométricas (Shape3D ), puntos de vista de la cámara, etc. Podemos definir tanto la geometría como la apariencia de los objetos. Los nodos de comportamiento (Behavior ) pueden o no aparecer, y permiten la interacción y el movimiento de los objetos. La plataforma de vista ( ViewPlatform ) permite tratar la posición del observador.

Pasos para construir un mundo 3D

A la hora de generar nuestro mundo virtual 3D, el resultado será un conjunto de elementos  interconectados formando el mundo. El proceso de creación del mundo consta de varios pasos. Si el universo no es demasiado complejo podemos utilizar un objeto SimpleUniverse, que simplifica bastante la tarea de definir el mundo virtual, aunque no permite tener varias vistas simultáneas.  Vemos ejemplos de construcción de cada universo:

Objetos primitivos

Java 3D incorpora una serie de objetos primitivos, descendientes de la clase objeto geométrico genérica (Shape3D). Dichos elementos son:

	La caja (Box): define un cubo indicando las longitudes de las aristas X, Y y Z:  Box(float dimX, float dimY, float dimZ)
	El cono (Cone): define un cono dados un radio (radio de la base) y una altura  Cone(float radio, float altura)
	El cilindro (Cylinder): define un cilindro, dados un radio y una altura  Cylinder(float radio, float altura)
	La esfera (Sphere): define una esfera, dado un radio  Sphere(float radio)
	El cubo de color (ColorCube): define un cubo con un color en cada cara. Se pasa como parámetro una escala con respecto a un tamaño de arista de 2 metros.  ColorCube(double escala)

Se pueden construir objetos complejos combinando estos objetos simples. Además, Java 3D permite añadir texto 2D, texto 3D, polígonos y otras figuras.
 

Transformaciones en objetos

Un sistema de coordenadas en Java 3D es como sigue: el eje X es positivo hacia la derecha, el eje Y es positivo hacia arriba y el eje Z es positivo hacia el observador. Las distancias se miden en metros y los ángulos en radianes .

Los objetos Transform3D representan transformaciones geométricas 3D, que pueden ser traslaciones, rotaciones, escalados o una combinación de estos. Internamente, es una matriz de 4x4 doubles.  Se tienen, entre otros, los métodos:

void rotX(double angulo) void rotY(double angulo) void rotZ(double angulo)	Especifican una rotación en sentido antihorario sobre el eje que se indica (ángulo en radianes entre 0 y 2 PI)
void setTranslation( Vector3f traslacion)	Indica una traslación , indicando directamente el vector de traslación (componentes X, Y y Z)
void setScale(double escala) void setScale(Vector3d escala)	Se emplean para escalados (bien uniforme, bien definiendo una escala para cada dimensión)

Mediante el método mul(...) de Transform3D podremos formar transformaciones complejas multiplicando las simples.

Los objetos TransformGroup son contenedores de transformaciones geométricas, de modo que a todos los nodos contenidos en un nodo TransformGroup se les aplica dicha transformación. Podemos indicar qué transformación aplicar con el método:

void setTransform(Transform3D trans)

Otras características

Java 3D permite añadir a nuestros mundos virtuales otras posibilidades, que comentamos aquí brevemente:

• Podemos definir la apariencia de los objetos: colores, forma de dibujar los polígonos, atributos para aristas, vértices, etc, mediante la clase Appearance.
• Podemos interactuar con el mundo, y movernos por él, o mover objetos.
• Podemos realizar animaciones, y mover objetos o cambiarles características.
• Podemos añadir luces al mundo virtual.
• Podemos pegar texturas a los objetos y darles así mayor riqueza.

Figura 2. Ejemplo de aplicación de Sun

En este ejemplo podéis ver algunas de las características de Java 3D. Es una aplicación desarrollada por Sun, que permite navegar por mundos 3D:  Podéis descargar aquí la aplicación y aquí el código fuente.

6.5.2. JAI (Java Advanced Imaging)

JAI (Java Advanced Imaging) es una librería estándar de Java para la manipulación y el tratamiento de imágenes. Extiende la plataforma Java permitiendo añadir procesamiento de imágenes sofisticado y de alto nivel. Puede encontrarse información actualizada sobre JAI en:

JAI pretende ser una librería que soporte casi cualquier tipo de procesamiento de imágenes. Ofrece algunas ventajas con respecto a otras librerías de procesamiento de imágenes:

• Al estar hecha en Java, proporciona independencia de la plataforma .
• Está preparada para funcionar en arquitecturas cliente-servidor mediante RMI.
• Es flexible y extensible.
• Es independiente del dispositivo de captura que podamos tener.
• Permite tratar imágenes divididas en regiones (tiles).

En JAI se unifican los conceptos de imagen y operador, haciéndolos subclases de una misma clase padre. Un objeto de tipo operador tomará una o más imágenes fuente, y otros parámetros, y generará un resultado. Este mismo operador puede convertirse en una fuente para otro operador, formando así un grafo del procesamiento de imágenes.

Ejemplo: El siguiente ejemplo lee una imagen, la escala al doble de su tamaño y muestra el resultado.

Tratamiento de imágenes

JAI soporta 3 modelos de imágenes:

• El modelo productor/consumidor (push), el modelo básico de AWT.  En este modelo un objeto de tipo Image se emplea para obtener una referencia a un productor ( ImageProducer). Estos objetos están asociados a su vez a consumidores (ImageConsumer). Los filtros implementan ambas interfaces.

• El modelo de modo inmediato, un modelo avanzado de AWT.  Este modelo mantiene algunas de las características del modelo anterior, pero añade conceptos como un conjunto de filtros para imágenes 2D, más variedad de formatos de datos, etc. Se introduce el concepto de independencia del renderizado , el describir una imagen tal y como queremos verla, sin una instancia específica de la misma. Se añaden las capas:

• Renderable, con la que podemos manejar imágenes independientemente del renderizado, que sólo renderizan la imagen ante una petición concreta. Las clases RenderableImage y RenderableImageOp permiten definir imágenes y operadores de este tipo, respectivamente.

• Rendered, con la que se obtienen imágenes para un contexto dado. Las clases RenderedImage y RenderedImageOp permiten, respectivamente, definir imágenes y operadores en esta capa.

• El modelo de tubería (pull), el modelo propio de JAI. Se vale del modelo anterior, proporcionando clases que extienden de Renderable y Rendered.

Una operación de procesado de imagen en JAI puede resumirse en los pasos:

• Obtener la imagen o imágenes que se van a manipular (las fuentes). Podemos obtenerlas de un fichero (GIF, JPEG, etc), de un servidor remoto, o generar la imagen.
• Definir el grafo de procesamiento de imágenes . Esto consiste en definir qué operadores utilizar y cómo conectarlos (qué imagenes preceden a qué otras)
• Procesar el resultado:guardar la imagen en un fichero, mostrarla por pantalla, etc.

Obtención de imágenes

Veremos cómo leer imágenes de ficheros. Tenemos 3 alternativas:

• Leer imágenes cualesquiera (con un formato soportado por JAI, como GIF, JPEG, BMP, etc), mediante un stream de datos. Aplicamos el operador "stream", pasando un SeekableStream del que leer la imagen:

FileSeekableStream stream = 
		new FileSeekableStream("img.jpg");
RenderedOp img1 = JAI.create("stream", stream);

• Leer imágenes con FileLoad , aplicamos el operador del mismo nombre (siempre que el formato sea soportado por JAI):

RenderedImage r=
    (RenderedImage)JAI.create("fileload","f.gif");

• Leer imágenes con un formato concreto (por ejemplo, un fichero PNG). Se utiliza el operador correspondiente, con los parámetros que necesiten:

InputStream is = new FileInputStream("imagen.png");
ParameterBlock pb = new ParameterBlock();
pb.add(is);
RedenderedOp op = JAI.create("PNG", pb);

 

El grafo de procesamiento

Veamos ahora cómo componer grafos de procesamiento. Los nodos son las imágenes / operadores que intervienen en el proceso. Se tienen 2 tipos de grafos:

Los grafos renderizados son la forma más simple de renderizado. Son necesarios cuando se requiere trabajar directamente con los píxeles. Se componen de objetos Rendered , que normalmente son instancias de la clase RenderedOp . Las imágenes fuente son objetos RenderedImage .

Ejemplo: El siguiente ejemplo crea dos imágenes constantes y las suma:

ParameterBlock param1 = new ParameterBlock();
ParameterBlock param2 = new ParameterBlock();
...
RenderedOp im0 = JAI.create("constant", param1);
RenderedOp im1 = JAI.create("constant", param2);
RenderedOp im2 = JAI.create("add", im0, im1);

Los grafos renderizables se evalúan más tarde, cuando exista alguna petición de renderizado. Se construyen con nodos RenderableImage, que normalmente son instancias de la clase RenderableOp .

Ejemplo: El siguiente ejemplo lee una imagen, invierte los valores de los píxeles y añade un valor constante a los mismos.

RenderableImage ren = JAI.createRenderable("renderable", pb);
// Operación de inversión
ParameterBlock pb1 = new ParameterBlock();
pb1.addSource(ren);
RenderableOp Op1 = JAI.createRenderable("invert", pb1);
// Operación de suma de constante
ParameterBlock pb2 = new ParameterBlock();
pb2.addSource(Op1);        
pb2.add(2.0f);           
RenderableOp Op2 = JAI.createRenderable("addconst", pb2);

Operaciones

• Para grafos renderizables se tienen, entre otros, los métodos:

createRenderable (String name, ParameterBlock pBlock)

createRenderableCollection (String name, ParameterBlock pBlock)

• Para grafos renderizados se tienen, entre otros, los métodos:

create (String name, ParameterBlock pBlock, RenderingHints hints)

create (String name, RenderedImage renderedImage, Object param, Object param2 ...)

Podremos invocar así a las operaciones anteriores, por ejemplo:

RenderableOp im = JAI.createRenderable("nombre",paramBlock);
RenderedOp im2 = JAI.create ("nombre",imagen param1,param2)

 

Bloques de parámetros

Los parámetros que necesitan los operadores se pasan mediante objetos ParameterBlock o ParameterBlockJAI . El bloque de parámetros contiene la imagen o imágenes fuente de la operación, y un conjunto de parámetros utilizados por dicha operación, que son objetos.

Para añadir una imagen fuente a un bloque de parámetros se emplea el método:
 

addSource()

Para añadir el resto de parámetros, debemos distinguir entre las clases ParameterBlock y ParameterBlockJAI:

• En la clase ParameterBlock , añadiremos parámetros con el método:

add()

• Con ParameterBlockJAI se emplean los métodos set( ):

set(char c, String param)	set(double f, String param)
set(int i, String param)	set(Object obj, String param)

Un ejemplo: aplicamos una rotación que requiere 4 parámetros: la X origen, Y origen, ángulo de rotación e interpolación. Los dos primeros valores tienen por defecto 0.0F, y no los vamos a especificar.

interp = Interpolation.create(Interpolation.INTERP_NEAREST);
ParameterBlockJAI pb = new ParameterBlockJAI();
pb.addSource(im);
pb.set(1.2F, “angle”);
pb.set(interp, “interpolation”);