java - transparente - imagenes sin fondo como se llaman

Cómo hacer que un color sea transparente en una Imagen Buffered y guardar como PNG

Question

He estado buscando en la web para esto, pero no he encontrado ninguna ayuda decente.

Tengo una Imagen Buffered, que he leído con ImageIO. Ahora me gustaría hacer que un determinado color en esa imagen sea transparente y guardar la imagen como PNG.

Sé que no puedo simplemente "pintar" el color transparente por razones obvias, así que supongo que necesito algún tipo de filtro.

¿Alguien tiene un código de muestra para esto?

Answer 1

Gracias a PhilLo aquí hay una solución completa de mi aplicación de demostración.

public static void main(String[] args) throws Exception {
File in = new File("C://Users//Christoffer//Desktop//christoffer.jpg");
BufferedImage source = ImageIO.read(in);
int color = source.getRGB(0, 0);
Image image = makeColorTransparent(source, new Color(color));
BufferedImage transparent = imageToBufferedImage(image);
File out = new File("C://Users//Christoffer//Desktop//trans.PNG");
ImageIO.write(transparent, "PNG", out);
}
private static BufferedImage imageToBufferedImage(Image image) {
BufferedImage bufferedImage = new BufferedImage(image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = bufferedImage.createGraphics();
g2.drawImage(image, 0, 0, null);
g2.dispose();
return bufferedImage;
}
public static Image makeColorTransparent(BufferedImage im, final Color color) {
ImageFilter filter = new RGBImageFilter() {
// the color we are looking for... Alpha bits are set to opaque
public int markerRGB = color.getRGB() | 0xFF000000;
public final int filterRGB(int x, int y, int rgb) {
if ((rgb | 0xFF000000) == markerRGB) {
// Mark the alpha bits as zero - transparent
return 0x00FFFFFF & rgb;
} else {
// nothing to do
return rgb;
}
}
};
ImageProducer ip = new FilteredImageSource(im.getSource(), filter);
return Toolkit.getDefaultToolkit().createImage(ip);
}

Answer 2

Lo hice recientemente, para responder una pregunta de mi gerente de proyecto.
La función que transforma gris a transparencia es:

 private Image TransformGrayToTransparency(BufferedImage image)
{
ImageFilter filter = new RGBImageFilter()
{
public final int filterRGB(int x, int y, int rgb)
{
return (rgb << 8) & 0xFF000000;
}
};
ImageProducer ip = new FilteredImageSource(image.getSource(), filter);
return Toolkit.getDefaultToolkit().createImage(ip);
}

En realidad, actúa sobre una imagen de nivel de grises, así que solo copio un componente RGB (el R) a alfa, descartando los otros que son idénticos en mi caso.
Puedes adaptarlo para filtrar un color específico, ej. con una prueba de igualdad o rango, etc.
Por supuesto, BufferedImage debe ser del tipo BufferedImage.TYPE_INT_ARGB.

No abordo la cuestión del ahorro, ya que es bastante trivial, pero también puedo agregar esta página de códigos.

[EDITAR] Para convertir la imagen a imagen almacenada en búfer:

BufferedImage dest = new BufferedImage(
imageWidth, imageHeight,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = dest.createGraphics();
g2.drawImage(image, 0, 0, null);
g2.dispose();

[EDIT 2] Vengo después de que Christoffer publicó su solución completa, pero aquí está la mía, le muestro cómo hacer que una gama de colores sea transparente. Se puede mejorar, por ej. utilizando componentes HSB en su lugar.

import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageFilter;
import java.awt.image.ImageProducer;
import java.awt.image.RGBImageFilter;
import java.io.*;
import javax.imageio.ImageIO;
public class AddTransparency
{
AddTransparency() throws IOException
{
String imagePath = "E:/Documents/images/";
File inFile = new File(imagePath, "map.png");
BufferedImage image = ImageIO.read(inFile);
Image transpImg1 = TransformGrayToTransparency(image);
BufferedImage resultImage1 = ImageToBufferedImage(transpImg1, image.getWidth(), image.getHeight());
File outFile1 = new File(imagePath, "map_with_transparency1.png");
ImageIO.write(resultImage1, "PNG", outFile1);
Image transpImg2 = TransformColorToTransparency(image, new Color(0, 50, 77), new Color(200, 200, 255));
BufferedImage resultImage2 = ImageToBufferedImage(transpImg2, image.getWidth(), image.getHeight());
File outFile2 = new File(imagePath, "map_with_transparency2.png");
ImageIO.write(resultImage2, "PNG", outFile2);
}
private Image TransformGrayToTransparency(BufferedImage image)
{
ImageFilter filter = new RGBImageFilter()
{
public final int filterRGB(int x, int y, int rgb)
{
return (rgb << 8) & 0xFF000000;
}
};
ImageProducer ip = new FilteredImageSource(image.getSource(), filter);
return Toolkit.getDefaultToolkit().createImage(ip);
}
private Image TransformColorToTransparency(BufferedImage image, Color c1, Color c2)
{
// Primitive test, just an example
final int r1 = c1.getRed();
final int g1 = c1.getGreen();
final int b1 = c1.getBlue();
final int r2 = c2.getRed();
final int g2 = c2.getGreen();
final int b2 = c2.getBlue();
ImageFilter filter = new RGBImageFilter()
{
public final int filterRGB(int x, int y, int rgb)
{
int r = (rgb & 0xFF0000) >> 16;
int g = (rgb & 0xFF00) >> 8;
int b = rgb & 0xFF;
if (r >= r1 && r <= r2 &&
g >= g1 && g <= g2 &&
b >= b1 && b <= b2)
{
// Set fully transparent but keep color
return rgb & 0xFFFFFF;
}
return rgb;
}
};
ImageProducer ip = new FilteredImageSource(image.getSource(), filter);
return Toolkit.getDefaultToolkit().createImage(ip);
}
private BufferedImage ImageToBufferedImage(Image image, int width, int height)
{
BufferedImage dest = new BufferedImage(
width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = dest.createGraphics();
g2.drawImage(image, 0, 0, null);
g2.dispose();
return dest;
}
public static void main(String[] args) throws IOException
{
AddTransparency at = new AddTransparency();
}
}