在Java中旋转缓冲图像

Question

我正在尝试在Java中旋转缓冲图像。这是我正在使用的代码：

public static BufferedImage rotate(BufferedImage bimg, double angle) {
    int w = bimg.getWidth();
    int h = bimg.getHeight();
    Graphics2D graphic = bimg.createGraphics();
    graphic.rotate(Math.toRadians(angle), w / 2, h / 2);
    graphic.drawImage(bimg, null, 0, 0);
    graphic.dispose();
    return bimg;
}

我查看了许多关于这个问题的Stack Overflow问题和答案，但无法弄清楚为什么在尝试旋转图像时会出现切割的情况。以下是一个示例，显示了加载的图像： 加载的图像

当我点击旋转按钮并使用缓冲图像和90.0作为角度调用上述函数后，出现了下面这个图像: 切割的图像

有人能帮助我理解发生了什么以及如何修复它吗？

- Zugor

Answer 1

一如既往，互联网来拯救。这是我从其他资源/帖子/博客中拼凑在一起的代码，它将返回一个新的图像，该图像大小调整为包含旋转后的图像。

public BufferedImage rotateImageByDegrees(BufferedImage img, double angle) {
    double rads = Math.toRadians(angle);
    double sin = Math.abs(Math.sin(rads)), cos = Math.abs(Math.cos(rads));
    int w = img.getWidth();
    int h = img.getHeight();
    int newWidth = (int) Math.floor(w * cos + h * sin);
    int newHeight = (int) Math.floor(h * cos + w * sin);

    BufferedImage rotated = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2d = rotated.createGraphics();
    AffineTransform at = new AffineTransform();
    at.translate((newWidth - w) / 2, (newHeight - h) / 2);

    int x = w / 2;
    int y = h / 2;

    at.rotate(rads, x, y);
    g2d.setTransform(at);
    g2d.drawImage(img, 0, 0, this);
    g2d.setColor(Color.RED);
    g2d.drawRect(0, 0, newWidth - 1, newHeight - 1);
    g2d.dispose();

    return rotated;
}

更新

因此，使用这个PNG：

以及这段代码...

package javaapplication1.pkg040;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private BufferedImage master;
        private BufferedImage rotated;

        public TestPane() {
            try {
                master = ImageIO.read(new File("/Volumes/Disk02/Dropbox/MegaTokyo/Miho_Small.png"));
                rotated = rotateImageByDegrees(master, 0.0);
            } catch (IOException ex) {
                ex.printStackTrace();
            }

            Timer timer = new Timer(40, new ActionListener() {
                private double angle = 0;
                private double delta = 1.0;

                @Override
                public void actionPerformed(ActionEvent e) {
                    angle += delta;
                    rotated = rotateImageByDegrees(master, angle);
                    repaint();
                }
            });
            timer.start();
        }

        @Override
        public Dimension getPreferredSize() {
            return master == null
                         ? new Dimension(200, 200)
                         : new Dimension(master.getWidth(), master.getHeight());
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            if (rotated != null) {
                Graphics2D g2d = (Graphics2D) g.create();
                int x = (getWidth() - rotated.getWidth()) / 2;
                int y = (getHeight() - rotated.getHeight()) / 2;
                g2d.drawImage(rotated, x, y, this);
                g2d.dispose();
            }
        }

        public BufferedImage rotateImageByDegrees(BufferedImage img, double angle) {

            double rads = Math.toRadians(angle);
            double sin = Math.abs(Math.sin(rads)), cos = Math.abs(Math.cos(rads));
            int w = img.getWidth();
            int h = img.getHeight();
            int newWidth = (int) Math.floor(w * cos + h * sin);
            int newHeight = (int) Math.floor(h * cos + w * sin);

            BufferedImage rotated = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2d = rotated.createGraphics();
            AffineTransform at = new AffineTransform();
            at.translate((newWidth - w) / 2, (newHeight - h) / 2);

            int x = w / 2;
            int y = h / 2;

            at.rotate(rads, x, y);
            g2d.setTransform(at);
            g2d.drawImage(img, 0, 0, this);
            g2d.dispose();

            return rotated;
        }
    }

}

我可以生成类似于...的东西：

- MadProgrammer

---

所以，我已经使用基于 PNG 的图像重新测试了代码，对我来说它可以正常工作。我建议您考虑提出一个新问题，并提供一个可运行的示例，以展示您的问题，因为从我的角度来看，这似乎更相关于您如何使用代码。 - MadProgrammer

@MadProgrammer：我有一个关于你的代码的问题：在rotateImagesByDegree(...)中，几乎在底部有这一行代码：g2d.drawImage(img, 0, 0, this);这让我很困惑，因为它似乎是将原始图像（未旋转）绘制出来。然后在paintComponent的上面，有：g2d.drawImage(rotated, x, y, this);代码可以正常工作，但是你能否解释一下为什么要有两个绘制语句？谢谢。 - GitPhilter

@GitPhilter，你看到这行代码 g2d.setTransform(at); 了吗？它是将变换应用于“Graphics”上下文，从而定义旋转逻辑。 - MadProgrammer

@MadProgrammer 是的，我看到了。虽然我不知道我们是否在谈论同一件事情。我想了解为什么有两个不同的paint语句在两个不同的位置。为什么我们不能总是在paintComponent()中绘制旋转后的图像呢？这背后的逻辑是什么？ - GitPhilter

@GitPhilter 好的，所以 rotateImageByDegrees 接受原始图像并将其旋转一定角度。这会生成一个新的 BufferedImage。paintComponent 只是将旋转后的图像绘制到屏幕上，以便您可以看到结果。因此，您可以使用 rotateImageByDegrees 旋转图像，然后保存或执行任何您想要的操作 - 或者，如果您愿意，就像示例一样对其进行动画处理。 - MadProgrammer

Answer 2

这段代码从文件中读取图像，旋转一定角度，并将其写入另一个文件。它与带有透明度的 png 图像良好地工作：

public static void main(String[] args) throws IOException {
    BufferedImage image = ImageIO.read(
            Test.class.getResourceAsStream("/resources/image.png"));

    BufferedImage rotated = rotateImage(image, 45);

    ImageIO.write(rotated, "png",
            new FileOutputStream("resources/rotated.png"));
}

private static BufferedImage rotateImage(BufferedImage buffImage, double angle) {
    double radian = Math.toRadians(angle);
    double sin = Math.abs(Math.sin(radian));
    double cos = Math.abs(Math.cos(radian));

    int width = buffImage.getWidth();
    int height = buffImage.getHeight();

    int nWidth = (int) Math.floor((double) width * cos + (double) height * sin);
    int nHeight = (int) Math.floor((double) height * cos + (double) width * sin);

    BufferedImage rotatedImage = new BufferedImage(
            nWidth, nHeight, BufferedImage.TYPE_INT_ARGB);

    Graphics2D graphics = rotatedImage.createGraphics();

    graphics.setRenderingHint(
            RenderingHints.KEY_INTERPOLATION,
            RenderingHints.VALUE_INTERPOLATION_BICUBIC);

    graphics.translate((nWidth - width) / 2, (nHeight - height) / 2);
    // rotation around the center point
    graphics.rotate(radian, (double) (width / 2), (double) (height / 2));
    graphics.drawImage(buffImage, 0, 0, null);
    graphics.dispose();

    return rotatedImage;
}

image.png	rotated.png (45º) ⟳	rotated.png (-45º) ⟲

- user14940971

Answer 3

你得到混乱的图像结果是因为你将旋转后的图像绘制到了输入图像本身中。相反，你需要从一个新的BufferedImage创建图形。

public static BufferedImage rotate(BufferedImage bimg, double angle) {

    int w = bimg.getWidth();    
    int h = bimg.getHeight();

    BufferedImage rotated = new BufferedImage(w, h, bimg.getType());  
    Graphics2D graphic = rotated.createGraphics();
    graphic.rotate(Math.toRadians(angle), w/2, h/2);
    graphic.drawImage(bimg, null, 0, 0);
    graphic.dispose();
    return rotated;
}

请注意，如果您想避免出现裁切的角落，您需要调整输出BufferedImage的宽度和高度。

请注意，如果您想避免裁剪角落，需要调整输出BufferedImage的宽度和高度。

- Reza Lesmana

Answer 4

你需要考虑输出的大小调整和新的宽度和高度。请参见：https://stackoverflow.com/a/4787898/5420880

- Kenny Ingle

---

我不确定这行代码 GraphicsConfiguration gc = getDefaultConfiguration(); 是如何工作的。我在谷歌上搜索了一下，看到需要使用 GraphicsEnvironment 和 GraphicsDevice。但是我不确定如何使用它。我复制了推荐链接中的函数，但是出现了错误。 - Zugor