在java中动态调整BuffereImage的大小

我尝试使用AffineTransform和Scalr.resize调整缓冲图像的大小

这是我给他们的代码

使用Scalr.resize：

    BufferedImage buff = robot.createScreenCapture(new Rectangle(bufx,bufy,bufwidth,bufheight)); // x-coord, y-coord, width, height

    BufferedImage scrCapt = Scalr.resize(buff, Method.BALANCED, scrwidth, scrheight);

Exception in thread "Thread-2" java.lang.IllegalArgumentException: Width (0) and height (0) cannot be <= 0
at java.awt.image.DirectColorModel.createCompatibleWritableRaster(DirectColorModel.java:1016)
at java.awt.image.BufferedImage.<init>(BufferedImage.java:331)
at org.imgscalr.Scalr.createOptimalImage(Scalr.java:2006)
at org.imgscalr.Scalr.scaleImage(Scalr.java:2133)
at org.imgscalr.Scalr.resize(Scalr.java:1667)
at org.imgscalr.Scalr.resize(Scalr.java:1415)

使用仿射变换：

BufferedImage buff = robot.createScreenCapture(new Rectangle(bufx,bufy,bufwidth,bufheight)); // x-coord, y-coord, width, height

BufferedImage scrCapt = new BufferedImage(bufwidth,bufheight,BufferedImage.TYPE_INT_ARGB);
AffineTransform atscr = new AffineTransform();


atscr.scale(aspectRatioWidth,aspectRatioHeight);
AffineTransformOp scaleOp = new AffineTransformOp(atscr, AffineTransformOp.TYPE_BILINEAR);
scrCapt = scaleOp.filter(buff, scrCapt);

Exception in thread "Thread-2" java.awt.image.ImagingOpException: Unable to invert transform AffineTransform[[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
at java.awt.image.AffineTransformOp.validateTransform(AffineTransformOp.java:558)
at java.awt.image.AffineTransformOp.<init>(AffineTransformOp.java:151)

变量已在类的开头声明：

static int bufx = 0;
static int bufy = 0;
static int bufwidth = 1;
static int bufheight = 1;
static int scrwidth = 0;
static int scrheight = 0;
static float aspectRatioWidth = 0;
static float aspectRatioHeight = 0;

我在另一个方法中动态获取所有变量的值：

aspectRatioWidth = bufwidth/scrwidth;
aspectRatioHeight = bufheight/scrheight;

但是，当我运行此代码时，AffineTransform函数和Scalr.resize函数都出现错误：

    BufferedImage buff = robot.createScreenCapture(new Rectangle(bufx,bufy,bufwidth,bufheight)); // x-coord, y-coord, width, height

    BufferedImage scrCapt = Scalr.resize(buff, Method.BALANCED, scrwidth, scrheight);

Exception in thread "Thread-2" java.lang.IllegalArgumentException: Width (0) and height (0) cannot be <= 0
at java.awt.image.DirectColorModel.createCompatibleWritableRaster(DirectColorModel.java:1016)
at java.awt.image.BufferedImage.<init>(BufferedImage.java:331)
at org.imgscalr.Scalr.createOptimalImage(Scalr.java:2006)
at org.imgscalr.Scalr.scaleImage(Scalr.java:2133)
at org.imgscalr.Scalr.resize(Scalr.java:1667)
at org.imgscalr.Scalr.resize(Scalr.java:1415)

Scalr.resize：

    BufferedImage buff = robot.createScreenCapture(new Rectangle(bufx,bufy,bufwidth,bufheight)); // x-coord, y-coord, width, height

    BufferedImage scrCapt = Scalr.resize(buff, Method.BALANCED, scrwidth, scrheight);

Exception in thread "Thread-2" java.lang.IllegalArgumentException: Width (0) and height (0) cannot be <= 0
at java.awt.image.DirectColorModel.createCompatibleWritableRaster(DirectColorModel.java:1016)
at java.awt.image.BufferedImage.<init>(BufferedImage.java:331)
at org.imgscalr.Scalr.createOptimalImage(Scalr.java:2006)
at org.imgscalr.Scalr.scaleImage(Scalr.java:2133)
at org.imgscalr.Scalr.resize(Scalr.java:1667)
at org.imgscalr.Scalr.resize(Scalr.java:1415)

编辑（2）：

为了更清楚地了解到底发生了什么：

这是一个返回scrwidth和scrheight的方法

public static void showOnScreen( int screen, JFrame framenew )
   {
    GraphicsEnvironment ge = GraphicsEnvironment
      .getLocalGraphicsEnvironment();
    GraphicsDevice[] gs = ge.getScreenDevices();

  for (int i = 0; i < gs.length; i++) {
      screenwidth.add(gs[i].getDisplayMode().getWidth());
      screenheight.add(gs[i].getDisplayMode().getHeight());
}

scrwidth = screenwidth.get(screenwidth.size()-1);
scrheight = screenheight.get(screenheight.size()-1);




  System.out.print(ge);
  System.out.print(gs);
  if( screen > -1 && screen < gs.length )
  {gs[screen].setFullScreenWindow( framenew );}
  else if( gs.length > 0 )
  {gs[0].setFullScreenWindow( framenew );}
  else
  {throw new RuntimeException( "No Screens Found" );}}

和aspectRatios在运行中使用：

public void run() {
System.out.print("aspectRatioWidth:  ");
System.out.println(aspectRatioWidth);

System.out.print("aspectRatioHeight:  ");
System.out.println(aspectRatioHeight);

while(true){
    BufferedImage buff = robot.createScreenCapture(new Rectangle(bufx,bufy,bufwidth,bufheight)); // x-coord, y-coord, width, height

    BufferedImage resizedbuff = resizeImage(buff, aspectRatioWidth, aspectRatioHeight);}

---

您正在执行int除法，该除法始终返回int，此处为0，因为您的屏幕尺寸可能大于图像尺寸：

aspectRatioWidth = bufwidth/scrwidth;
aspectRatioHeight = bufheight/scrheight;

解决方案：将数字转换为双精度，然后进行双除法

aspectRatioWidth = (double) bufwidth/scrwidth;
aspectRatioHeight = (double) bufheight/scrheight;

---

编辑

不确定最终要做什么——在GUI中发布计算机屏幕的图像？如果是这样的话，也许像

import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Graphics;
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.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.util.List;

import javax.swing.*;

public class ChangeVars extends JPanel {
   private static final int PREF_W = 400;
   private static final int PREF_H = PREF_W;
   private static final int DELAY = 20;
   public BufferedImage displayImage;
   private MyWorker myWorker;

   public ChangeVars() {
      try {
         myWorker = new MyWorker(DELAY);
         myWorker.execute();
      } catch (AWTException e) {
         e.printStackTrace();
      }
   }

   @Override
   // to initialize the panel to something
   public Dimension getPreferredSize() {
      if (isPreferredSizeSet()) {
         return super.getPreferredSize();
      }
      return new Dimension(PREF_W, PREF_H);
   }

   @Override
   protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      if (displayImage != null) {
         g.drawImage(displayImage, 0, 0, null);
      }
   }

   public void stopWorker() {
      if (myWorker != null && !myWorker.isDone()) {
         myWorker.setRunning(false);
         myWorker.cancel(true);
      }
   }

   private class MyWorker extends SwingWorker<Void, BufferedImage> {

      private volatile boolean running = true;
      private Robot robot;
      private int delay;

      public MyWorker(int delay) throws AWTException {
         this.delay = delay;
         robot = new Robot();
      }

      @Override
      protected Void doInBackground() throws Exception {
         while (running) {
            Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
            Rectangle screenRect = new Rectangle(0, 0, d.width, d.height);
            BufferedImage img = robot.createScreenCapture(screenRect);
            publish(img);
            Thread.sleep(delay);
         }
         return null;
      }

      @Override
      protected void process(List<BufferedImage> chunks) {
         for (BufferedImage image : chunks) {
            Dimension sz = getSize();
            double scaleX = (double) sz.width / image.getWidth();
            double scaleY = (double) sz.height / image.getHeight();
            AffineTransform transform = AffineTransform.getScaleInstance(
                  scaleX, scaleY);
            AffineTransformOp transformOp = new AffineTransformOp(transform,
                  AffineTransformOp.TYPE_BILINEAR);
            displayImage = new BufferedImage(sz.width, sz.height,
                  BufferedImage.TYPE_INT_ARGB);
            displayImage = transformOp.filter(image, displayImage);
            repaint();
         }
      }

      public void setRunning(boolean running) {
         this.running = running;
      }

      public boolean getRunning() {
         return running;
      }

   }

   private static void createAndShowGui() {
      final ChangeVars changeVars = new ChangeVars();

      JFrame frame = new JFrame("ChangeVars");
      frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
      frame.addWindowListener(new WindowAdapter() {

         @Override
         public void windowClosing(WindowEvent e) {
            if (changeVars != null) {
               changeVars.stopWorker();
            }
            System.exit(0);
         }

      });
      frame.getContentPane().add(changeVars);
      frame.pack();
      frame.setLocationByPlatform(true);
      frame.setVisible(true);
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            createAndShowGui();
         }
      });
   }
}

import java.awt.AWTException；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Rectangle；
导入java.awt.Robot；
导入java.awt.Toolkit；
导入java.awt.event.WindowAdapter；
导入java.awt.event.WindowEvent；
导入java.awt.geom.AffineTransform；
导入java.awt.image.AffineTransformOp；
导入java.awt.image.buffereImage；
导入java.util.List；
导入javax.swing.*；
公共类ChangeVars扩展了JPanel{
专用静态最终整型预加值W=400；
私有静态final int PREF_H=PREF_W；
专用静态最终整数延迟=20；
公共缓冲区图像显示图像；
私人我的工人我的工人；
公共变更变量（）{
试一试{
myWorker=新myWorker（延迟）；
myWorker.execute（）；
}捕获（awtexe）{
e、 printStackTrace（）；
}
}
@凌驾
//将面板初始化为某个值
公共维度getPreferredSize（）{
如果（isPreferredSizeSet（））{
返回super.getPreferredSize（）；
}
返回新维度（PREF_W，PREF_H）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
if（displayImage！=null）{
g、 drawImage（displayImage，0，0，null）；
}
}
公职人员（）{
if（myWorker！=null&&！myWorker.isDone（））{
myWorker.setRunning（false）；
myWorker.cancel（true）；
}
}
私有类MyWorker扩展SwingWorker{
private volatile boolean running=true；
私人机器人；
私有整数延迟；
public MyWorker（int delay）抛出AWTException{
延迟=延迟；
机器人=新机器人（）；
}
@凌驾
受保护的Void doInBackground（）引发异常{
（跑步时）{
维度d=Toolkit.getDefaultToolkit（）.getScreenSize（）；
矩形screenRect=新矩形（0，0，d.宽度，d.高度）；
BuffereImage img=robot.createScreenCapture（screenRect）；
出版（img）；
睡眠（延迟）；
}
返回null；
}
@凌驾
受保护的无效进程（列表块）{
用于（BuffereImage图像：块）{
维度sz=getSize（）；
double scaleX=（double）sz.width/image.getWidth（）；
double scaleY=（double）sz.height/image.getHeight（）；
AffineTransform transform=AffineTransform.getScaleInstance(
scaleX，scaleY）；
AffineTransformOp transformOp=新的AffineTransformOp（转换，
仿射变换类型（双线性）；
显示图像=新的缓冲区图像（sz.width，sz.height，
BuffereImage.TYPE_INT_ARGB）；
displayImage=transformOp.filter（图像，显示图像）；
重新油漆（）；
}
}
公共void setRunning（布尔运行）{
这就是跑步；
}
公共布尔getRunning（）{
返回运行；
}
}
私有静态void createAndShowGui（）{
final ChangeVars ChangeVars=新ChangeVars（）；
JFrame=新JFrame（“变更变量”）；
frame.setDefaultCloseOperation（JFrame.DO\u NOTHING\u ON\u CLOSE）；
frame.addWindowListener（新的WindowAdapter（）{
@凌驾
公共无效窗口关闭（WindowEvent e）{
if（changeVars！=null）{
changeVars.stopWorker（）；
}
系统出口（0）；
}
});
frame.getContentPane（）.add（changeVars）；
frame.pack（）；
frame.setLocationByPlatform（真）；
frame.setVisible（true）；
}
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
公开募捐{
createAndShowGui（）；
}
});
}
}

尽管更简单的方法是让paintComponent进行缩放：

@Override
protected void paintComponent(Graphics g) {
  super.paintComponent(g);
  if (displayImage != null) {
     int width = getWidth();
     int height = getHeight();
     g.drawImage(displayImage, 0, 0, width, height, null);
  }
}

// ....

  @Override
  protected void process(List<BufferedImage> chunks) {
     for (BufferedImage image : chunks) {
        displayImage = image;
        repaint();
     }
  }

@覆盖
受保护组件（图形g）{
超级组件（g）；
if（displayImage！=null）{
int width=getWidth（）；
int height=getHeight（）；
g、 drawImage（displayImage，0，0，宽度，高度，空）；
}
}
// ....
@凌驾
受保护的无效进程（列表块）{
用于（BuffereImage图像：块）{
显示图像=图像；
重新油漆（）；
}
}

所以。。。你做了一些改变（你做了我推荐的改变了吗？）——你的改变做了什么？你的代码现在运行了吗？你还看到例外吗？是的，我把数字改成了双倍。当我在方法内部执行除法时，它给出了正确的值，该除法返回bufwidth、BufHight和所有变量，但是当我在run（）内部打印aspectRatioWidth和AspectratioHight时，它返回了零。我理解这是因为当run（）实现时，所有变量的值还没有增加，我如何确定