logo标签列表

使用Java BufferedImage和Graphics将图像绘制到JFrame上

javaswinggraphicsbufferedimageawtrobot
4

我试图捕捉屏幕并将图像递归地绘制到JFrame上，同时对图像进行缩放（以创建当您在镜子中看到镜子时获得的效果）。

我遇到了代码问题-它没有绘制任何图形。我做错了什么？

import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;


public class ScreenCapture extends JFrame {

    BufferedImage screenCapture;
    Graphics screenCaptureGraphics;
    private static int recurseCount = 0;
    private static float $scale = 0.9f;
    private static float scale = 1.0f;
    private static int height;
    private static int width;

    ScreenCapture() {
        try {
            screenCapture = new Robot().createScreenCapture(
                       new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()) );
            height = screenCapture.getHeight();
            width = screenCapture.getWidth();
            setSize(new Dimension(width, height));
            addWindowListener(new LocalWindowListener());
            Graphics g = recursiveDraw(screenCapture, getGraphics());
            paint(g);
        } catch (HeadlessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (AWTException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private Graphics recursiveDraw(BufferedImage img, Graphics imgG) {
        updateScale(++recurseCount);
        float newWidth = scale*width;
        float newHeight = scale*height;
        int w = (int) newWidth;
        int h = (int) newHeight;
        System.out.println("W: " + w + "; H: " + h);
        if (w >= 10 && h >= 10) {
            //scale image
            System.out.print("Creating scaled Image...");
            Image scaled = img.getScaledInstance(w, h, Image.SCALE_SMOOTH);
            BufferedImage resized = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            imgG = resized.createGraphics();
            imgG.drawImage(scaled, 0, 0, null);
            System.out.println("...Image drawn to graphics");
            //return new graphics
            return recursiveDraw(resized, imgG);
        } else {
            //otherwise return old graphics
            System.out.println("Completed.");
            return imgG;
        }
    }


    private void updateScale(int count) {
        for (int i=0; i<count; i++) {
            scale *= $scale;
        }
        System.out.println("Updated scale: " + scale + "; Recurse count: " + recurseCount);
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                new ScreenCapture().setVisible(true);
            }
        });
    }

    private class LocalWindowListener extends WindowAdapter {
        @Override
        public void windowClosing(WindowEvent e) {
            System.exit(0); return;
        }
    }

}

编辑： 在@andrew-thompson的回答后，我尝试了以下方法：

ScreenCapture() {
    try {
        screenCapture = new Robot().createScreenCapture(
                   new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()) );
        height = screenCapture.getHeight();
        width = screenCapture.getWidth();
        setSize(new Dimension(width, height));
        addWindowListener(new LocalWindowListener());
        setLayout(new GridLayout());
        add(new PaintPanel());
    } catch (HeadlessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (AWTException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

private class PaintPanel extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
        g=recursiveDraw(screenCapture, g);
        //what to do with g?
    }
}

我仍然遇到同样的问题，即不知道如何让BufferedImage绘制到图形上下文中。

不需要使用 LocalWindowListener。只需调用 JFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) 即可。 - Andrew Thompson
哦，我之前添加了这个，因为 EXIT_ON_CLOSE 也无法正常工作；因为我的 updateScale 循环出现了问题，一直在运行。在我修复循环后，我忘记改回来了。 - Ozzy
4个回答
6
我建议您将Swing代码与递归图像创建代码分开。事实上，考虑创建一个静态方法来创建并返回BufferedImage，并且该方法中没有Swing代码。然后，当您的GUI希望时，调用该方法并获取图像，可以将其写入磁盘或在JLabel的ImageIcon中显示。
当我做这件事（实际上是今天），我创建了一个具有以下签名的递归方法：
private static void recursiveDraw(BufferedImage img, Graphics imgG, double scale) {

通过以下伪代码示例可以了解该方法的实现：

start recursiveDraw method 
   // most important: all recursions must have a good ending condition: 
   get img height and width. If either <= a min, return 
   create a BufferedImage, smlImg, for the smaller image using the height, 
        width and scale factor 
   Get the Graphics object, smlG, from the small image 
   Use smlG.drawImage(...) overload to draw the big image in shrunken 
        form onto the little image 
   recursively call recursiveDraw passing in smlImg, smlG, and scale. 
   dispose of smlG 
   draw smlImg (the small image) onto the bigger one using the bigger's 
        Graphics object (passed into this method) and a different 
        overload of the drawImage method. 
end recursiveDraw method

这种算法生成的图片如下所示：这里输入图片描述 例如：
import java.awt.*;
import java.awt.Dialog.ModalityType;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class RecursiveDrawTest {
   private static final Color BACKGRND_1 = Color.green;
   private static final Color BACKGRND_2 = Color.MAGENTA;
   private static final Color FOREGRND_1 = Color.blue;
   private static final Color FOREGRND_2 = Color.RED;

   private static void createAndShowGui() {
      final JPanel mainPanel = new JPanel(new BorderLayout());
      final JSlider slider = new JSlider(50, 90, 65);
      slider.setMajorTickSpacing(10);
      slider.setMinorTickSpacing(5);
      slider.setPaintLabels(true);
      slider.setPaintTicks(true);

      JPanel southPanel = new JPanel();
      southPanel.add(new JLabel("Percent Size Reduction:"));
      southPanel.add(slider);
      southPanel.add(new JButton(new AbstractAction("Create Recursive Image") {

         @Override
         public void actionPerformed(ActionEvent arg0) {
            try {
               double scale = slider.getValue() / 100.0;
               BufferedImage img = createRecursiveImg(scale);
               ImageIcon icon = new ImageIcon(img);
               JLabel label = new JLabel(icon);

               Window win = SwingUtilities.getWindowAncestor(mainPanel);
               JDialog dialog = new JDialog(win, "Image", ModalityType.MODELESS);
               dialog.getContentPane().add(label);
               dialog.pack();
               dialog.setLocationRelativeTo(null);
               dialog.setVisible(true);
            } catch (AWTException e) {
               e.printStackTrace();
            }
         }
      }));

      mainPanel.add(new JScrollPane(new JLabel(new ImageIcon(createLabelImg()))), 
            BorderLayout.CENTER);
      mainPanel.add(southPanel, BorderLayout.PAGE_END);

      JFrame frame = new JFrame("RecursiveDrawTest");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.getContentPane().add(mainPanel);
      frame.pack();
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
   }

   // create a background image to display in a JLabel so that the GUI
   // won't be boring.
   private static BufferedImage createLabelImg() {
      Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
      int width = (5 * d.width) / 6;
      int height = (5 * d.height) / 6;
      BufferedImage img = new BufferedImage(width, height, 
            BufferedImage.TYPE_INT_ARGB);
      Graphics2D g2 = img.createGraphics();
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2.setPaint(new GradientPaint(0, 0, BACKGRND_1, 40, 40, BACKGRND_2, true));
      g2.fillRect(0, 0, width, height);
      g2.setPaint(new GradientPaint(0, height, FOREGRND_1, 40, height - 40, FOREGRND_2, true));
      g2.fillOval(0, 0, 2 * width, 2 * height);
      g2.dispose();
      return img;
   }

   // non-recursive image to get the initial image that will be drawn recursively
   public static BufferedImage createRecursiveImg(double scale) throws AWTException {
      Robot robot = new Robot();
      Dimension screenSz = Toolkit.getDefaultToolkit().getScreenSize();
      Rectangle screenRect = new Rectangle(screenSz);
      BufferedImage img = robot.createScreenCapture(screenRect);
      Graphics g = img.getGraphics();
      recursiveDraw(img, g, scale); // call recursive method
      g.dispose();
      return img;
   }

   // recursive method to draw image inside of image
   private static void recursiveDraw(BufferedImage img, Graphics g, double scale) {
      int w = img.getWidth();
      int h = img.getHeight();

      int smlW = (int)(w * scale);
      int smlH = (int)(h * scale);
      // criteria to end recursion
      if (smlW <= 1 || smlH <= 1) {
         return; 
      }

      BufferedImage smlImg = new BufferedImage(smlW, smlH, BufferedImage.TYPE_INT_ARGB);
      Graphics smlG = smlImg.getGraphics();
      // draw big image in little image, scaled to little image
      smlG.drawImage(img, 0, 0, smlW, smlH, null);

      // recursive call
      recursiveDraw(smlImg, smlG, scale);
      smlG.dispose(); // clear resources when done with them

      // these guys center the smaller img on the bigger
      int smlX = (w - smlW) / 2;
      int smlY = (h - smlH) / 2;
      // draw small img on big img
      g.drawImage(smlImg, smlX, smlY, smlW, smlH, null);
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            createAndShowGui();
         }
      });
   }
}
哈哈，你是可Fubar的。我不想在Java论坛上发布这个问题，以免有人说我在给别人喂食答案。 - Ozzy
我的程序递归得很好，输出字符串告诉我每次递归的新尺寸（它会向下缩放，直到接近10x10像素）。但是我在实际绘制图形时遇到了麻烦，特别是在另一个图形之上。 - Ozzy
@user1031312：在BufferedImage上进行重叠绘制，而不是在组件上进行。一旦你的BufferedImage完成，你可以将它显示在由JLabel持有的ImageIcon中。 - Hovercraft Full Of Eels
5
 Graphics g = recursiveDraw(screenCapture, getGraphics());

不要调用getGraphics()方法。覆盖paint(Graphics)1方法并使用提供的Graphics实例。

  1. 在使用Swing时，最好覆盖JComponent或JPanel的paintComponent(Graphics)方法。然后将其添加到顶层容器中。
谢谢您的回答。但我不确定如何实现它 - 请检查EDIT之后的新代码？在paintComponent方法中，我不确定该如何使用Graphics对象使其工作。 - Ozzy
2

这是您所希望的内容吗：

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Robot;
import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import javax.imageio.ImageIO;

import javax.swing.*;

public class CaptureScreen extends JPanel
{
    private BufferedImage screenShot;
    private JLabel imageLabel;
    private BufferedImage secondScreenShot;

    public void createAndDisplayGUI()
    {
        JFrame frame = new JFrame("CAPTURE SCREEN");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationByPlatform(true);

        //imageLabel = new JLabel();
        //getImageForLabel();
        //add(imageLabel);

        frame.getContentPane().add(this);
        frame.setSize(600, 600);
        frame.setVisible(true);
    }

    private void getImageForLabel()
    {
        Robot robot = null;
        try
        {
            robot = new Robot();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        screenShot = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
        ImageIcon icon = new ImageIcon(screenShot);
        imageLabel.setIcon(icon);
    }

    public void paintComponent(Graphics g)
    {
        Robot robot = null;
        try
        {
            robot = new Robot();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        screenShot = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
        secondScreenShot = getScaledImage((Image) screenShot, 300, 300);

        g.drawImage(screenShot, 0, 0, null);
        g.drawImage(secondScreenShot, 150, 150, null);
    }

    private BufferedImage getScaledImage(Image srcImg, int w, int h)
    {
        BufferedImage resizedImg = new BufferedImage(w, h, BufferedImage.TRANSLUCENT);
        Graphics2D g2 = resizedImg.createGraphics();
        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g2.drawImage(srcImg, 0, 0, w, h, null);
        g2.dispose();
        return resizedImg;
    }

    public static void main(String... args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            public void run()
            {
                new CaptureScreen().createAndDisplayGUI();
            }
        });
    }
}

今日免费次数已满, 请开通会员/明日再来
我知道如何在Swing中显示图像，但我的问题是如何在一个图像上绘制另一个图形或创建一个图像并在其上绘制较小的图像。我知道有其他方法可以实现相同的效果，但这些方法与我的原始问题无关。我正在学习如何绘制。 - Ozzy
1

摆脱递归。创建一个正确尺寸的单个缓冲图像，并为其创建Graphics对象。只需使用循环来绘制不断缩小的比例图像，直到达到所选阈值为止。最后在paintComponent()内使用g.drawImage()将您的图像绘制到屏幕上。如果保留递归，则需要传递图像并不断覆盖缩小的图像。您不需要从方法中返回任何内容。

只需使用循环逐渐绘制缩小到您选择的任何阈值的图像。这实际上是我现在的问题。如果我知道，我就不需要其他方法了。我将g.drawImage（scaledImage，0，0，null）移入paintComponent，但它会擦掉旧图像的背景，因此我得到了一个较小的图像，但带有灰色背景。 - Ozzy
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接