0

我一直在使用 ConvolveOp 时遇到一些问题，可以通过将我正在使用的BufferedImage的imageType设置为TYPE_INT_ARGB_PRE来解决这些问题（请参见此处的相关 SO 答案）。

不幸的是，我并不完全理解选择这种不同的 imageType 的所有含义，而且我似乎也找不到好的参考，所以让我在这里尝试一下：

将 BufferedImage 的 imageType 从 TYPE_INT_ARGB 更改为 TYPE_INT_ARGB_PRE 会影响哪些绘图操作？它只是BufferedImageOps吗？或者它是否会影响图像的Graphics对象上的任何绘制命令，或者如果将图像绘制到不同的 Graphics 对象上，它会影响图像的渲染方式？

4

1 回答 1

3

这基本上取决于绘画算法是否考虑到图像是否使用预乘 alpha 的信息。

正如评论中已经指出的那样：结果在大多数情况下是相同的 - 至少对于基本的绘图操作：无论您是将“非预乘”图像绘制成预乘图像，反之亦然，都不会影响结果，因为差异是在内部处理的。

一个特例是BufferedImageOps。JavaDoc 注释明确说明了如何处理 alpha 通道，并且传入错误类型的图像可能会导致您链接到的问题中描述的不良结果。

很难确定他们决定采用这种方式的“原因” 。BufferedImageOp但是这里有一个（有些模糊的）陈述：当对单个源的像素进行操作（和组合）时，并且这些像素具有不同的 alpha 值，对 alpha 通道的处理可能会变得繁琐。阿尔法通道应该发生什么并不总是很明显。

例如，想象一堆像素（此处为 ARGB，带有浮点值）：

[1.00, 1.00, 0.00, 0.00]  // 100% red, 100% alpha
[0.00, 0.00, 0.00, 0.00]  // black,      0% alpha
[0.00, 0.00, 0.00, 0.00]  // black,      0% alpha

现在，您想对这些像素进行卷积（如您链接到的问题中所示）。然后内核可以是

[0.33...]
[0.33...],
[0.33...]

这意味着结果的中心像素应该只是所有像素的“平均值”（忽略边界 - 大致与 一样ConvolveOp#EDGE_ZERO_FILL）。

然后卷积将平等地对待所有通道。对于非预乘图像，这意味着生成的像素是低不透明度的深红色：

[0.33, 0.33, 0.00, 0.00]

对于预乘图像，假设分量与它们的 alpha 值相乘。在这种情况下，生成的像素将是完全红色的，具有相同的不透明度：

[0.33, 1.00, 0.00, 0.00]

做这背后的数学是乏味的。事实上，对我来说手动操作太乏味了——所以这里有一个例子：

Alpha预乘

和对应的代码

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.util.Locale;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class PremultipliedAlphaTest
{
    public static void main(String[] args) 
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }    

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new PremultipliedAlphaTestPanel());
        f.setSize(550,500);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }
}


class PremultipliedAlphaTestPanel extends JPanel
{
    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        Graphics2D g = (Graphics2D)gr;
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, getWidth(), getHeight());

        BufferedImage imageS = createImage(BufferedImage.TYPE_INT_ARGB);
        BufferedImage imageP = createImage(BufferedImage.TYPE_INT_ARGB_PRE);

        Kernel kernel = new Kernel(1, 3, 
            new float[]{ 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f });
        ConvolveOp op = new ConvolveOp(kernel, ConvolveOp.EDGE_ZERO_FILL, null);
        BufferedImage resultS = op.filter(imageS, null);
        BufferedImage resultP = op.filter(imageP, null);

        g.setColor(Color.BLACK);
        g.setFont(new Font("Monospaced", Font.PLAIN, 12));

        g.drawString("Straight:", 10, 40);

        print(g, 2, 1, imageS.getRGB(0, 0));
        print(g, 2, 2, imageS.getRGB(0, 1));
        print(g, 2, 3, imageS.getRGB(0, 2));

        print(g, 7, 2, resultS.getRGB(0, 1));


        g.drawString("Premultiplied:", 10, 240);

        print(g, 2, 5, imageP.getRGB(0, 0));
        print(g, 2, 6, imageP.getRGB(0, 1));
        print(g, 2, 7, imageP.getRGB(0, 2));

        print(g, 7, 6, resultP.getRGB(0, 1));

        g.scale(50, 50);

        g.drawImage(imageS,  1, 1, null);
        g.drawImage(resultS, 6, 1, null);

        g.drawImage(imageP,  1, 5, null);
        g.drawImage(resultP, 6, 5, null);
    }

    private static void print(Graphics2D g, int px, int py, int argb)
    {
        g.drawString(stringFor(argb), px*50+5, py*50+25);
    }


    private static String stringFor(int argb)
    {
        int a = (argb >> 24) & 0xFF;
        int r = (argb >> 16) & 0xFF;
        int g = (argb >>  8) & 0xFF;
        int b = (argb      ) & 0xFF;
        float fa = a / 255.0f;
        float fr = r / 255.0f;
        float fg = g / 255.0f;
        float fb = b / 255.0f;
        return String.format(Locale.ENGLISH,
            "%4.2f %4.2f %4.2f %4.2f", fa, fr, fg, fb);
    }

    private static BufferedImage createImage(int type)
    {
        BufferedImage b = new BufferedImage(1,3, type);
        Graphics2D g = b.createGraphics();
        g.setColor(new Color(1.0f,0.0f,0.0f,1.0f));
        g.fillRect(0, 0, 1, 1);
        g.setColor(new Color(0.0f,0.0f,0.0f,0.0f));
        g.fillRect(0, 1, 1, 1);
        g.setColor(new Color(0.0f,0.0f,0.0f,0.0f));
        g.fillRect(0, 2, 1, 1);
        g.dispose();
        return b;
    }
}
于 2015-03-10T22:41:59.070 回答