Jeu de BufferedImage masque alpha en Java

J'ai deux BufferedImages je l'ai chargé dans la de png. La première contient une image, la seconde d'un masque alpha de l'image.

Je veux créer une image à partir de les deux, en appliquant le masque alpha. Mon google-fu m'abandonne.

Je sais comment charger/enregistrer les images, j'ai seulement besoin d'un peu où je vais partir deux BufferedImages à un BufferedImage avec le bon canal alpha.

J'ai édité ma réponse à donner un code correct (à faire ce que vous avez demandé!) d'une autre manière.

InformationsquelleAutor Zarkonnen | 2008-10-21

Votre solution pourrait être améliorée par l'extraction des données RVB plus d'un pixel à la fois(voir http://java.sun.com/javase/6/docs/api/java/awt/image/BufferedImage.html), et par la création de trois objets de Couleur à chaque itération de la boucle interne.

final int width = image.getWidth();
int[] imgData = new int[width];
int[] maskData = new int[width];

for (int y = 0; y < image.getHeight(); y++) {
    //fetch a line of data from each image
    image.getRGB(0, y, width, 1, imgData, 0, 1);
    mask.getRGB(0, y, width, 1, maskData, 0, 1);
    //apply the mask
    for (int x = 0; x < width; x++) {
        int color = imgData[x] & 0x00FFFFFF; //mask away any alpha present
        int maskColor = (maskData[x] & 0x00FF0000) << 8; //shift red into alpha bits
        color |= maskColor;
        imgData[x] = color;
    }
    //replace the data
    image.setRGB(0, y, width, 1, imgData, 0, 1);
}

InformationsquelleAutor Michael Myers

Je suis en retard de cette réponse, mais peut-être que c'est de l'utiliser pour quelqu'un de toute façon. C'est plus simple et plus efficace de la version de Michael Myers méthode:

public void applyGrayscaleMaskToAlpha(BufferedImage image, BufferedImage mask)
{
    int width = image.getWidth();
    int height = image.getHeight();

    int[] imagePixels = image.getRGB(0, 0, width, height, null, 0, width);
    int[] maskPixels = mask.getRGB(0, 0, width, height, null, 0, width);

    for (int i = 0; i < imagePixels.length; i++)
    {
        int color = imagePixels[i] & 0x00ffffff; //Mask preexisting alpha
        int alpha = maskPixels[i] << 24; //Shift blue to alpha
        imagePixels[i] = color | alpha;
    }

    image.setRGB(0, 0, width, height, imagePixels, 0, width);
}

Il lit tous les pixels dans un tableau au début, donc ne nécessitant qu'une boucle for. Aussi, il déplace le blue byte à l'alpha (de la couleur du masque), au lieu de la première masquer le rouge octet, puis les déplacer.

Comme les autres méthodes, il suppose que les deux images ont les mêmes dimensions.

InformationsquelleAutor Meyer

J'ai joué récemment un peu avec ce genre de choses, pour afficher une image sur une autre, et à l'évanouissement d'une image en niveaux de gris.

Aussi masquage d'une image avec un masque avec de la transparence (ma précédente version de ce message!).

J'ai pris mon petit programme de test et modifié un peu pour obtenir le résultat voulu.

Voici les bits:

TestMask() throws IOException
{
    m_images = new BufferedImage[3];
    m_images[0] = ImageIO.read(new File("E:/Documents/images/map.png"));
    m_images[1] = ImageIO.read(new File("E:/Documents/images/mapMask3.png"));
    Image transpImg = TransformGrayToTransparency(m_images[1]);
    m_images[2] = ApplyTransparency(m_images[0], transpImg);
}

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 BufferedImage ApplyTransparency(BufferedImage image, Image mask)
{
    BufferedImage dest = new BufferedImage(
            image.getWidth(), image.getHeight(),
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2 = dest.createGraphics();
    g2.drawImage(image, 0, 0, null);
    AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.DST_IN, 1.0F);
    g2.setComposite(ac);
    g2.drawImage(mask, 0, 0, null);
    g2.dispose();
    return dest;
}

Le reste juste à afficher les images dans un peu de Swing panneau.

Notez que le masque de l'image est en niveaux de gris, noir de devenir une totale transparence, blanc devenant opaque.

Bien que vous avez résolu votre problème, j'ai pensé que je pourrais partager mon prendre sur elle. Il utilise un peu plus de Java-ish méthode, à l'aide de classes standard de filtrer les images.

En fait, ma méthode utilise un peu plus de mémoire (une nouvelle image) et je ne suis pas sûr que c'est plus rapide (pour la mesure de performances pourrait être intéressant), mais il est un peu plus abstrait.

Au moins, vous avez le choix! 🙂

InformationsquelleAutor PhiLho

Pour ceux qui sont à l'aide de l'alpha de l'image d'origine.

J'ai écrit ce code dans Koltin, le point clé ici est que si vous avez l'alpha sur votre image d'origine, vous devez multiplier ces canaux.

Koltin Version:

    val width = this.width
    val imgData = IntArray(width)
    val maskData = IntArray(width)

    for(y in 0..(this.height - 1)) {

      this.getRGB(0, y, width, 1, imgData, 0, 1)
      mask.getRGB(0, y, width, 1, maskData, 0, 1)

      for (x in 0..(this.width - 1)) {

        val maskAlpha = (maskData[x] and 0x000000FF)/ 255f
        val imageAlpha = ((imgData[x] shr 24) and 0x000000FF) / 255f
        val rgb = imgData[x] and 0x00FFFFFF
        val alpha = ((maskAlpha * imageAlpha) * 255).toInt() shl 24
        imgData[x] = rgb or alpha
      }
      this.setRGB(0, y, width, 1, imgData, 0, 1)
    }

Version de Java (juste traduit de Kotlin)

    int width = image.getWidth();
    int[] imgData = new int[width];
    int[] maskData = new int[width];

    for (int y = 0; y < image.getHeight(); y ++) {

        image.getRGB(0, y, width, 1, imgData, 0, 1);
        mask.getRGB(0, y, width, 1, maskData, 0, 1);

        for (int x = 0; x < image.getWidth(); x ++) {

            //Normalize (0 - 1)
            float maskAlpha = (maskData[x] & 0x000000FF)/ 255f;
            float imageAlpha = ((imgData[x] >> 24) & 0x000000FF) / 255f;

            //Image without alpha channel
            int rgb = imgData[x] & 0x00FFFFFF;

            //Multiplied alpha
            int alpha = ((int) ((maskAlpha * imageAlpha) * 255)) << 24;

            //Add alpha to image
            imgData[x] = rgb | alpha;
        }
        image.setRGB(0, y, width, 1, imgData, 0, 1);
    }

InformationsquelleAutor Thiago Medeiros dos Santos

En fait, j'ai pensé à elle. Ce n'est probablement pas un rapide façon de le faire, mais il fonctionne:

for (int y = 0; y < image.getHeight(); y++) {
    for (int x = 0; x < image.getWidth(); x++) {
        Color c = new Color(image.getRGB(x, y));
        Color maskC = new Color(mask.getRGB(x, y));
        Color maskedColor = new Color(c.getRed(), c.getGreen(), c.getBlue(),
            maskC.getRed());
        resultImg.setRGB(x, y, maskedColor.getRGB());
    }
}

InformationsquelleAutor Zarkonnen

Vous devez vous connecter pour publier un commentaire.