Question

这可能听起来像是一个奇怪的标题，但请耐心等待，是的原因：

我正在尝试在灰色背景上的文本周围生成白色光晕。

为了生成光晕，我创建了一个比文本更大的新BufferedImage，然后我将文本以白色绘制到图像的画布上，并通过ConvolveOp在图像上运行高斯模糊，希望像这样的东西：

enter image description here

起初，当发出的光线比文字的灰色背景更暗时，我有点惊讶：

enter image description here

但经过一番思考后，我理解了这个问题：

卷积独立地对每个颜色通道（R，G，B和A）进行操作以计算模糊图像。图片的透明背景颜色值为0x00000000，即完全透明的黑色！因此，当卷积滤镜在图像上运行时，它不仅会混合alpha值，还会将黑色混合到白色像素的RGB值中。这就是发光变暗的原因。

要解决此问题，我需要将图像初始化为0x00FFFFFF，即完全透明的白色，但如果我只是设置该颜色并用它填充矩形，那么它就像Java一样无效“嗯，这是一个完全透明的矩形，你正在绘制！这不会改变图像......让我为你优化它......完成......欢迎你。”。

如果我改为将颜色设置为0x01FFFFFF，即几乎完全透明的白色，它会绘制矩形并且发光看起来很漂亮，除了我周围有一个非常微弱的白框...

有没有办法可以将图像初始化为0x00FFFFFF？

更新：

我找到了一种方法，但它可能并非如您所能获得的那样：

我在图像上绘制了一个不透明的白色矩形，然后在图像上运行RescaleOp，将所有alpha值设置为0.这样可行，但就性能而言，它可能是一种糟糕的方法。

我能以某种方式做得更好吗？

PS：我也对开创这种发光效果的完全不同的建议持开放态度

Answer 1

使用初始方法时发光较暗的主要原因很可能是您没有使用带有预乘alpha分量的图像。 ConvolveOp的JavaDoc包含有关在卷积过程中如何处理alpha分量的一些信息。

你可以使用“几乎完全透明的白色”解决这个问题。但另外，您可以简单地使用具有预乘alpha的图像，即具有TYPE_INT_ARGB_PRE类型的图像。

这是一个MCVE，用一些文字绘制一个面板，并在文本周围发出一些脉冲发光（移除计时器并设置固定半径以消除脉冲 - 我无法抗拒在这里玩一点...）。

Glow

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;

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

public class TextGlowTest
{
    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 TextGlowPanel());
        f.setSize(300,200);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }
}

class TextGlowPanel extends JPanel
{
    private BufferedImage image;
    private int radius = 1;

    TextGlowPanel()
    {
        Timer t = new Timer(50, new ActionListener()
        {
            long startMillis = -1;

            @Override
            public void actionPerformed(ActionEvent e)
            {
                if (startMillis == -1)
                {
                    startMillis = System.currentTimeMillis();
                }
                long d = System.currentTimeMillis() - startMillis;
                double s = d / 1000.0;
                radius = (int)(1 + 15 * (Math.sin(s * 3) * 0.5 + 0.5));
                repaint();
            }
        });
        t.start();
    }

    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        gr.setColor(Color.GRAY);

        int w = getWidth();
        int h = getHeight();
        gr.fillRect(0, 0, w, h);

        if (image == null || image.getWidth() != w || image.getHeight() != h)
        {
            // Must be prmultiplied!
            image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE);
        }

        Graphics2D g = image.createGraphics();
        Font font = g.getFont().deriveFont(70.0f).deriveFont(Font.BOLD);
        g.setFont(font);

        g.setComposite(AlphaComposite.Src);
        g.setColor(new Color(255,255,255,0));
        g.fillRect(0,0,w,h);

        g.setComposite(AlphaComposite.SrcOver);
        g.setColor(new Color(255,255,255,0));
        g.fillRect(0,0,w,h);

        g.setColor(Color.WHITE);
        g.drawString("Glow!", 50, 100);

        image = getGaussianBlurFilter(radius, true).filter(image, null);
        image = getGaussianBlurFilter(radius, false).filter(image, null);

        g.dispose();

        g = image.createGraphics();
        g.setFont(font);
        g.setColor(Color.BLUE);
        g.drawString("Glow!", 50, 100);
        g.dispose();

        gr.drawImage(image, 0, 0, null);
    }


    // From
    // http://www.java2s.com/Code/Java/Advanced-Graphics/GaussianBlurDemo.htm
    public static ConvolveOp getGaussianBlurFilter(
        int radius, boolean horizontal)
    {
        if (radius < 1)
        {
            throw new IllegalArgumentException("Radius must be >= 1");
        }

        int size = radius * 2 + 1;
        float[] data = new float[size];

        float sigma = radius / 3.0f;
        float twoSigmaSquare = 2.0f * sigma * sigma;
        float sigmaRoot = (float) Math.sqrt(twoSigmaSquare * Math.PI);
        float total = 0.0f;

        for (int i = -radius; i <= radius; i++)
        {
            float distance = i * i;
            int index = i + radius;
            data[index] =
                (float) Math.exp(-distance / twoSigmaSquare) / sigmaRoot;
            total += data[index];
        }

        for (int i = 0; i < data.length; i++)
        {
            data[i] /= total;
        }

        Kernel kernel = null;
        if (horizontal)
        {
            kernel = new Kernel(size, 1, data);
        }
        else
        {
            kernel = new Kernel(1, size, data);
        }
        return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
    }
}

Answer 2

我发现clearRect应该绘制透明色。

g.setBackground(new Color(0x00FFFFFF, true));
g.clearRect(0, 0, img.getWidth(), img.getHeight());

您还应该能够通过直接设置像素数据来强制BufferedImage填充透明色。

public static void forceFill(BufferedImage img, int rgb) {
    for(int x = 0; x < img.getWidth(); x++) {
        for(int y = 0; y < img.getHeight(); y++) {
            img.setRGB(x, y, rgb);
        }
    }
}

目前尚未明确记录，但我对其进行了测试，setRGB似乎接受了ARGB值。

在Java BufferedImage中绘制完全透明的“白色”

2 个答案: