subir - poner imagen en panel java

Aplicando un tinte a una imagen en java.

Question

Estoy tratando de crear varios estilos visuales similares para mis programas, cada uno con un tema de color diferente. Para hacer esto, he implementado el uso de iconos para representar los diferentes estados de JCheckBox y JRadioButton . En lugar de hacer un conjunto completo de iconos para cada color posible, ¿hay alguna manera de que pueda tomar un conjunto y cambiar el matiz / saturación / luminosidad / alfa de la imagen antes de mostrarla?

Answer 1

Debido a que todos los métodos que encontré no funcionaron para mí por la razón que sea, aquí hay una manera fácil de abordar esto (no se necesitan bibliotecas adicionales):

/**
 * Colors an image with specified color.
 * @param r Red value. Between 0 and 1
 * @param g Green value. Between 0 and 1
 * @param b Blue value. Between 0 and 1
 * @param src The image to color
 * @return The colored image
 */
protected BufferedImage color(float r, float g, float b, BufferedImage src) {

    // Copy image ( who made that so complicated :< )
    BufferedImage newImage = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TRANSLUCENT);
    Graphics2D graphics = newImage.createGraphics();
    graphics.drawImage(src, 0, 0, null);
    graphics.dispose();

    // Color image
    for (int i = 0; i < newImage.getWidth(); i++) {
        for (int j = 0; j < newImage.getHeight(); j++) {
            int ax = newImage.getColorModel().getAlpha(newImage.getRaster().getDataElements(i, j, null));
            int rx = newImage.getColorModel().getRed(newImage.getRaster().getDataElements(i, j, null));
            int gx = newImage.getColorModel().getGreen(newImage.getRaster().getDataElements(i, j, null));
            int bx = newImage.getColorModel().getBlue(newImage.getRaster().getDataElements(i, j, null));
            rx *= r;
            gx *= g;
            bx *= b;
            newImage.setRGB(i, j, (ax << 24) | (rx << 16) | (gx << 8) | (bx << 0));
        }
    }
    return newImage;
}

Una imagen en negro siempre permanecerá en negro, pero una imagen en blanco será el color que especifique. Este método recorre cada píxel y multiplica los valores rojos verdes y azules de la imagen con parámetros. Este es el comportamiento exacto del método OpenGL glColor3f () . Los parámetros R, G y B deben ser de 0.0F a 1.0F.

Este método no tiene ningún problema con los valores alfa.

Answer 2

Esto no es exactamente teñido, es más como aplicarle otra capa, pero funciona para mí:

public static BufferedImage colorImage(BufferedImage loadImg, int red, int green, int blue, int alpha /*Also the intesity*/) {
    Graphics g = loadImg.getGraphics();
    g.setColor(new Color(red, green, blue, alpha));
    g.fillRect(0, 0, loadImg.getWidth(), loadImg.getHeight());
    g.dispose();
    return loadImg;
}

Answer 3

Hay una forma, pero tendrás que hacer uso de algunas transformaciones de BufferedImage. Una vez que los cree, guárdelos o guárdelos para poder reutilizarlos fácilmente más tarde. Esencialmente, usted desea comenzar con una imagen en negro (color de origen # 000000) que solo usa la capa alfa para desactivar los píxeles (también proporciona suavizado suave). Por ejemplo, en su imagen de origen, cada píxel es negro, pero el canal alfa difiere de píxel a píxel.

Primero, lea este artículo para obtener información de fondo: http://www.javalobby.org/articles/ultimate-image/

Una vez que haya terminado con esa cartilla, debe cargar su imagen en una imagen almacenada:

BufferedImage loadImg = ImageUtil.loadImage("C:/Images/myimg.png");

A continuación, debe crear una nueva BufferedImage para convertirla en:

public BufferedImage colorImage(BufferedImage loadImg, int red, int green, int blue) {
    BufferedImage img = new BufferedImage(loadImg.getWidth(), loadImg.getHeight(),
        BufferedImage.TRANSLUCENT);
    Graphics2D graphics = img.createGraphics(); 
    Color newColor = new Color(red, green, blue, 0 /* alpha needs to be zero */);
    graphics.setXORMode(newColor);
    graphics.drawImage(loadImg, null, 0, 0);
    graphics.dispose();
    return img;
}

Esencialmente, el setXORMode XORRA el color que le proporcionas con el color en la imagen de origen. Si la imagen de origen es negra, el color que proporcione se escribirá según lo especifique. Con el nuevo color que usa "0" para el canal alfa, se respetarán los valores del canal alfa original. El resultado final es el compuesto que está buscando.

Editar:

Puede cargar el BufferedImage inicial de una de dos maneras. Lo más fácil es usar la API de ImageIO más reciente de Java: http://download.oracle.com/javase/6/docs/api/javax/imageio/ImageIO.html para cargar el archivo directamente en BufferedImage. La llamada se vería algo así:

BufferedImage img = ImageIO.read(url); 

Alternativamente, puede crear un método para leer la imagen usando el Kit de herramientas.

public BufferedImage loadImage(String url) {
    ImageIcon icon = new ImageIcon(url);
    Image image = icon.getImage();

    // Create empty BufferedImage, sized to Image
    BufferedImage buffImage = 
      new BufferedImage(
        image.getWidth(null), 
        image.getHeight(null), 
        BufferedImage.TYPE_INT_ARGB);

    // Draw Image into BufferedImage
    Graphics g = buffImage.getGraphics();
    g.drawImage(image, 0, 0, null);
    return buffImage;
}

Por supuesto, si presta atención, tenemos que hacer exactamente lo mismo para leer la imagen en una imagen almacenada en la memoria intermedia como lo hacemos para matizarla. En resumen, si cambió la firma del método colorImage para aceptar el objeto Image , solo necesita hacer un par de cambios en los métodos getWidth () y getHeight () para que funcione.

Answer 4

La forma más sencilla de hacerlo sería utilizando los filtros de imagen de JH Labs . Simplemente puede ajustar HSB llamando,

public BufferedImage setHSB(BufferedImage source, float hValue, float sValue, float bValue) {        
    com.jhlabs.image.HSBAdjustFilter hsb hsb = new HSBAdjustFilter();
    BufferedImage destination = hsb.createCompatibleDestImage(source, null);
    hsb.setHFactor(hValue);
    hsb.setSFactor(sValue);
    hsb.setBFactor(bValue);
    BufferedImage result = hsb.filter(bi, destination);

    return result;
}

Answer 5

Para calcular el promedio de cada componente de color y mantener el alfa original:

public static void tint(BufferedImage image, Color color) {
    for (int x = 0; x < image.getWidth(); x++) {
        for (int y = 0; y < image.getHeight(); y++) {
            Color pixelColor = new Color(image.getRGB(x, y), true);
            int r = (pixelColor.getRed() + color.getRed()) / 2;
            int g = (pixelColor.getGreen() + color.getGreen()) / 2;
            int b = (pixelColor.getBlue() + color.getBlue()) / 2;
            int a = pixelColor.getAlpha();
            int rgba = (a << 24) | (r << 16) | (g << 8) | b;
            image.setRGB(x, y, rgba);
        }
    }
}

Esto funciona mejor para mi caso.

Answer 6

Probé todas las soluciones en esta página, no tuve suerte. El Xor one (respuesta aceptada) no funcionó para mí: se tiñó de un extraño color amarillo en lugar del color que estaba dando como argumento sin importar cuál fuera el argumento. Finalmente encontré un enfoque que me funciona, aunque es un poco desordenado. Pensé que lo agregaría en caso de que alguien más tenga los mismos problemas que yo con las otras soluciones. ¡Aclamaciones!

/** Tints the given image with the given color.
 * @param loadImg - the image to paint and tint
 * @param color - the color to tint. Alpha value of input color isn''t used.
 * @return A tinted version of loadImg */
public static BufferedImage tint(BufferedImage loadImg, Color color) {
    BufferedImage img = new BufferedImage(loadImg.getWidth(), loadImg.getHeight(),
            BufferedImage.TRANSLUCENT);
    final float tintOpacity = 0.45f;
    Graphics2D g2d = img.createGraphics(); 

    //Draw the base image
    g2d.drawImage(loadImg, null, 0, 0);
    //Set the color to a transparent version of the input color
    g2d.setColor(new Color(color.getRed() / 255f, color.getGreen() / 255f, 
        color.getBlue() / 255f, tintOpacity));

    //Iterate over every pixel, if it isn''t transparent paint over it
    Raster data = loadImg.getData();
    for(int x = data.getMinX(); x < data.getWidth(); x++){
        for(int y = data.getMinY(); y < data.getHeight(); y++){
            int[] pixel = data.getPixel(x, y, new int[4]);
            if(pixel[3] > 0){ //If pixel isn''t full alpha. Could also be pixel[3]==255
                g2d.fillRect(x, y, 1, 1);
            }
        }
    }
    g2d.dispose();
    return img;
}

Answer 7

public static void tint(BufferedImage img) {

    for (int x = 0; x < img.getWidth(); x++) {
        for (int y = 0; y < img.getHeight(); y++) {

            Color color = new Color(img.getRGB(x, y));

            // do something with the color :) (change the hue, saturation and/or brightness)
            // float[] hsb = new float[3];
            // Color.RGBtoHSB(color.getRed(), old.getGreen(), old.getBlue(), hsb);

            // or just call brighter to just tint it
            Color brighter = color.brighter();

            img.setRGB(x, y, brighter.getRGB());
        }
    }
}