Trabajar con imágenes en Java

1. Información general

En este tutorial, echaremos un vistazo a algunas bibliotecas de procesamiento de imágenes disponibles y realizaremos una operación de procesamiento de imágenes simple: cargar una imagen y dibujar una forma en ella.

Probaremos la biblioteca AWT (y un poco de Swing), ImageJ, OpenIMAJ y TwelveMonkeys.

2. AWT

AWT es una biblioteca Java incorporada que permite al usuario realizar operaciones simples relacionadas con la visualización, como crear una ventana, definir botones y oyentes, etc. También incluye métodos que permiten a un usuario editar imágenes. No requiere instalación ya que se envía con Java.

2.1. Cargando una imagen

Lo primero es crear un objeto BufferedImage a partir de una imagen guardada en nuestra unidad de disco:

String imagePath = "path/to/your/image.jpg"; BufferedImage myPicture = ImageIO.read(new File(imagePath)); 

2.2. Editar una imagen

Para dibujar una forma en una imagen, tendremos que usar el objeto Graphics relacionado con la imagen cargada. El objeto gráfico encapsula las propiedades necesarias para realizar operaciones básicas de renderizado. Graphics2D es una clase que amplía Graphics . Proporciona más control sobre formas bidimensionales.

En este caso particular, necesitamos Graphic2D para extender el ancho de la forma para que sea claramente visible. Lo logramos aumentando su propiedad s troke . Luego establecemos un color y dibujamos un rectángulo de tal manera que la forma esté a diez px de los bordes de la imagen:

Graphics2D g = (Graphics2D) myPicture.getGraphics(); g.setStroke(new BasicStroke(3)); g.setColor(Color.BLUE); g.drawRect(10, 10, myPicture.getWidth() - 20, myPicture.getHeight() - 20); 

2.3. Visualización de una imagen

Ahora que hemos dibujado algo en nuestra imagen, nos gustaría mostrarlo. Podemos hacerlo usando objetos de la biblioteca Swing. Primero, creamos el objeto JLabel que representa un área de visualización para texto o imagen:

JLabel picLabel = new JLabel(new ImageIcon(myPicture));

Luego agregue nuestro JLabel a JPanel , que podemos tratar como de la GUI basada en Java:

JPanel jPanel = new JPanel(); jPanel.add(picLabel);

Al final, agregamos todo a JFrame, que es una ventana que se muestra en una pantalla. Tenemos que establecer el tamaño para no tener que expandir esta ventana cada vez que ejecutamos nuestro programa:

JFrame f = new JFrame(); f.setSize(new Dimension(myPicture.getWidth(), myPicture.getHeight())); f.add(jPanel); f.setVisible(true);

3. ImageJ

ImageJ es un software basado en Java creado para trabajar con imágenes. Tiene bastantes complementos, disponibles aquí. Usaremos solo API, ya que queremos realizar el procesamiento por nosotros mismos.

Es una biblioteca bastante poderosa, mejor que Swing y AWT, ya que su propósito de creación fue el procesamiento de imágenes y no las operaciones de GUI. Los complementos contienen muchos algoritmos de uso gratuito, lo cual es bueno cuando queremos aprender a procesar imágenes y ver rápidamente los resultados, en lugar de resolver problemas matemáticos y de optimización basados ​​en algoritmos IP.

3.1. Dependencia de Maven

Para comenzar a trabajar con ImageJ, simplemente agregue una dependencia al archivo pom.xml de su proyecto :

 net.imagej ij 1.51h 

Encontrará la versión más reciente en el repositorio de Maven.

3.2. Cargando una imagen

Para cargar la imagen, debe usar el método estático openImage () , de la clase IJ :

ImagePlus imp = IJ.openImage("path/to/your/image.jpg");

3.3. Editar una imagen

Para editar una imagen, tendremos que usar métodos del objeto ImageProcessor adjunto a nuestro objeto ImagePlus . Piense en ello como un objeto Graphics en AWT:

ImageProcessor ip = imp.getProcessor(); ip.setColor(Color.BLUE); ip.setLineWidth(4); ip.drawRect(10, 10, imp.getWidth() - 20, imp.getHeight() - 20);

3.4. Visualización de una imagen

Solo necesita llamar al método show () del objeto ImagePlus :

imp.show();

4. OpenIMAJ

OpenIMAJ es un conjunto de bibliotecas de Java enfocadas no solo en la visión por computadora y el procesamiento de video, sino también en el aprendizaje automático, el procesamiento de audio, el trabajo con Hadoop y mucho más. Todas las partes del proyecto OpenIMAJ se pueden encontrar aquí, en "Módulos". Solo necesitamos la parte de procesamiento de imágenes.

4.1. Dependencia de Maven

Para comenzar a trabajar con OpenIMAJ, simplemente agregue una dependencia al archivo pom.xml de su proyecto :

 org.openimaj core-image 1.3.5 

Encontrará la última versión aquí.

4.1. Cargando una imagen

To load an image, use ImageUtilities.readMBF() method:

MBFImage image = ImageUtilities.readMBF(new File("path/to/your/image.jpg")); 

MBF stands for the multiband floating-point image (RGB in this example, but it's not the only way to represent colors).

4.2. Editing an Image

To draw the rectangle, we need to define its shape which is polygon consisting of 4 points (top left, bottom left, bottom right, top right):

Point2d tl = new Point2dImpl(10, 10); Point2d bl = new Point2dImpl(10, image.getHeight() - 10); Point2d br = new Point2dImpl(image.getWidth() - 10, image.getHeight() - 10); Point2d tr = new Point2dImpl(image.getWidth() - 10, 10); Polygon polygon = new Polygon(Arrays.asList(tl, bl, br, tr));

As you might have noticed, in image processing Y-axis is reversed. After defining the shape, we need to draw it:

image.drawPolygon(polygon, 4, new Float[] { 0f, 0f, 255.0f });

Drawing method takes 3 arguments: shape, line thickness and RGB channel values represented by Float array.

4.3. Displaying an Image

We need to use DisplayUtilities:

DisplayUtilities.display(image);

5. TwelveMonkeysImageIO

The TwelveMonkeysImageIO library is intended as an extension to the Java ImageIO API, with support for a larger number of formats.

Most of the time, the code will look the same as the built-in Java code, but it will function with additional image formats, after adding the necessary dependencies.

By default, Java supports only these five formats for images: JPEG, PNG, BMP, WEBMP, GIF.

If we attempt to work with an image file in a different format, our application will not be able to read it and will throw a NullPointerException when accessing the BufferedImage variable.

TwelveMonkeys adds supports for the following formats: PNM, PSD, TIFF, HDR, IFF, PCX, PICT, SGI, TGA, ICNS, ICO, CUR, Thumbs.db, SVG, WMF.

To work with images in a specific format, we need to add the corresponding dependency, such as imageio-jpeg or imageio-tiff.

You can find the full list of dependencies in the TwelveMonkeys documentation.

Let's create an example that reads a .ico image. The code will look the same as the AWT section, except we will open a different image:

String imagePath = "path/to/your/image.ico"; BufferedImage myPicture = ImageIO.read(new File(imagePath));

For this example to work, we need to add the TwelveMonkeys dependency that contains support for .ico images, which is the imageio-bmp dependency, along with the imageio-core dependency:

 com.twelvemonkeys.imageio imageio-bmp 3.3.2   com.twelvemonkeys.imageio imageio-core 3.3.2 

And this is all! The built-in ImageIO Java API loads the plugins automatically at runtime. Now our project will work with .ico images as well.

6. Summary

Le han presentado 4 bibliotecas que pueden ayudarlo a trabajar con imágenes. Yendo más allá, es posible que desee buscar algunos algoritmos de procesamiento de imágenes, como extraer bordes, mejorar el contraste, usar filtros o detección de rostros.

Para esos propósitos, podría ser mejor comenzar a aprender ImageJ u OpenIMAJ. Ambos son fáciles de incluir en un proyecto y son mucho más poderosos que AWT en cuanto al procesamiento de imágenes.

Estos ejemplos de procesamiento de imágenes se pueden encontrar en el proyecto GitHub.