0

我需要绘制动画帧，其中每个像素都是作为算法的结果动态计算的。因此，全屏动画每帧可能需要数百万次操作。如果可能的话，我想达到最高的刷新率，最好是每秒 20 到 30+ 帧。

有人可以告诉我如何设计/编写高度优化的架构以在 java 中实现极快的帧刷新吗？

这需要独立于平台，所以我不能利用硬件加速。代码将在每个用户的计算机上执行，而不是在中央服务器上。当然，我是从简化用于在每帧内生成像素值的算法的角度来单独处理这个问题的，但是这个问题是关于高速逐帧刷新帧间的架构，与使用的算法无关在每一帧内生成像素值。例如，在对这篇帖子的回答中，我正在寻找诸如使用以下方法：

  • 缓冲图像，
  • 双缓冲，
  • 多线程，
  • 加速离屏图像，
  • 其他帧间方法等

我在下面写了一些示例代码来模拟这个问题。在我的笔记本电脑上全屏显示时，下面的代码每帧单独刷新 1,300,000+ 像素并具有唯一值。在具有四个处理器和 8 GB 内存的机器上，每帧需要 500 毫秒。我怀疑我在下面没有正确使用 BufferedImage，我真的很想了解其他帧间、架构级技术来优化下面的代码，与我最终用来计算每个像素值的算法无关-框架。您的代码示例和文章链接将不胜感激。

从逐帧（帧间）架构的角度，而不是从帧内的角度，如何改进下面的代码？ 

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class TestBuffer {
    private static void createAndShowUI() {
        TestPanel fastGraphicsPanel = new TestPanel();
        JFrame frame = new JFrame("This Needs A Faster Architecture!");
        frame.getContentPane().add(fastGraphicsPanel);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setPreferredSize(new Dimension(800,600));
        frame.setResizable(true);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
    public static void main(String[] args) {java.awt.EventQueue.invokeLater(new Runnable() {  
    public void run() {createAndShowUI();}});}
}

@SuppressWarnings("serial")
class TestPanel extends JPanel {
    int w, h;
    private static int WIDTH = 700;
    private static int HEIGHT = 500;
    private static final Color BACKGROUND_COLOR = Color.white;
    private BufferedImage bImg;
    private Color color = Color.black;

    public TestPanel() {
        bImg =  new BufferedImage(WIDTH, HEIGHT,BufferedImage.TYPE_INT_RGB);
        Graphics g = bImg.getGraphics();
        g.setColor(BACKGROUND_COLOR);
        g.fillRect(0, 0, WIDTH, HEIGHT);

        Timer myTimer = new Timer(10, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if(w!=0&&h!=0){
                    if(WIDTH!=w&&HEIGHT!=h){
                        WIDTH = w; HEIGHT = h;
                        bImg =  new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
                    }
                }
                repaint();
            }
        });
        myTimer.setInitialDelay(0);
        myTimer.setRepeats(true);
        myTimer.setCoalesce(true);
        myTimer.start();
        g.dispose();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        w = getWidth();
        h = getHeight();
//      System.out.println("w, h are: "+w+", "+h);
        long startTime = System.currentTimeMillis();
        g.drawImage(bImg, 0, 0, null);
        long endDrawImageTime = System.currentTimeMillis();
        Graphics2D g2 = (Graphics2D) g;
        drawRandomScreen(g2);
        long endDrawScreenTime = System.currentTimeMillis();
        long stopTime = System.currentTimeMillis();
        long drawImageTime = endDrawImageTime - startTime;
        long drawScreenTime = endDrawScreenTime - endDrawImageTime;
        long elapsedTime = stopTime - startTime;
        System.out.println(drawImageTime+", "+drawScreenTime+", "+elapsedTime); 
    }

    private void drawRandomScreen(Graphics2D g2) {
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        for(int i=0;i<WIDTH;i++){
            for(int j=0;j<HEIGHT;j++){
                    color = new Color((int) (Math.random() * 255),(int) (Math.random() * 255),(int) (Math.random() * 255));
                    g2.setColor(color);
                    g2.drawLine(i, j, i, j);
            }
        }
    }
}
4

3 回答 3

2

在给出的示例中，drawRandomScreen()在事件分派线程上执行。作为替代方案，让模型在单独的线程（或多个线程）上演化，并使用观察者模式以可持续的速率（例如 25 Hz）对生成的图像进行采样。同步访问共享图像缓冲区。此处检查了一个完整的示例。配置文件以验证正在进行的优化工作。

于 2013-06-26T09:59:28.787 回答
1

而不是通过 Graphics2D 进行交互，您应该直接与图像数据交互。这是我的代码，我的笔记本电脑可以以 20 帧/秒（全屏）的速度运行

 @SuppressWarnings("serial")
class TestPanel extends JPanel {
    int w, h;
    private static int WIDTH = 700;
    private static int HEIGHT = 500;
    private static final Color BACKGROUND_COLOR = Color.white;
    private BufferedImage bImg;
    private Color color = Color.black;

    public TestPanel() {
        bImg =  new BufferedImage(WIDTH, HEIGHT,BufferedImage.TYPE_INT_RGB);
        Graphics g = bImg.getGraphics();
        g.setColor(BACKGROUND_COLOR);
        g.fillRect(0, 0, WIDTH, HEIGHT);

        Timer myTimer = new Timer(10, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if(w!=0&&h!=0){
                    if(WIDTH!=w&&HEIGHT!=h){
                        WIDTH = w; HEIGHT = h;
                        System.out.println("create");
                        bImg =  new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
                    }
                }
                repaint();
            }
        });
        myTimer.setInitialDelay(0);
        myTimer.setRepeats(true);
        myTimer.setCoalesce(true);
        myTimer.start();
        g.dispose();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        w = getWidth();
        h = getHeight();
//      System.out.println("w, h are: "+w+", "+h);
        long startTime = System.currentTimeMillis();
        long endDrawImageTime = System.currentTimeMillis();
//        Graphics2D g2 = (Graphics2D) g;
        drawRandomScreen(bImg);
        g.drawImage(bImg, 0, 0, null);
        long endDrawScreenTime = System.currentTimeMillis();
        long stopTime = System.currentTimeMillis();
        long drawImageTime = endDrawImageTime - startTime;
        long drawScreenTime = endDrawScreenTime - endDrawImageTime;
        long elapsedTime = stopTime - startTime;
        System.out.println(drawImageTime+", "+drawScreenTime+", "+elapsedTime); 
    }

    private void drawRandomScreen(BufferedImage image) {

        final int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
        final int width = image.getWidth();
        final int height = image.getHeight();

        long startTime = System.currentTimeMillis();
//        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
//                RenderingHints.VALUE_ANTIALIAS_ON);
        Random r = new Random();
        for(int i=0;i<width;i++){
            for(int j=0;j<height;j++){
                    color = new Color(r.nextInt(255),r.nextInt(255),r.nextInt(255));
                    int pos = j*width+i;
                    pixels[pos] = color.hashCode();

            }
        }
        long stopTime = System.currentTimeMillis();
        System.out.println("time "+(stopTime-startTime));
    }
}
于 2013-06-26T03:37:01.320 回答
1

这是您的新代码。在我的笔记本电脑中，全屏可以以 150 帧/秒的速度运行。可以看到，函数drawRandomScreen的执行时间只有drawImageTime的1/2。

private void drawRandomScreen(BufferedImage image) {

    final int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
    final int width = image.getWidth();
    final int height = image.getHeight();

    long startTime = System.currentTimeMillis();
    Random r = new Random();
    int size = pixels.length;
    //swap 100 times
    int maxPixelsSwap = 1000;
    size-=maxPixelsSwap;
    for (int i = 0; i < 100; i++) {
        int src = r.nextInt(size);            
        int des = src+r.nextInt(size-src);
        int swapsize = r.nextInt(maxPixelsSwap); //maximium
        int[] temp = new int[swapsize];
        System.arraycopy(pixels, des, temp, 0, swapsize);
        System.arraycopy(pixels, src, pixels, des, swapsize);
        System.arraycopy(temp, 0, pixels, src, swapsize);

    }

    size = pixels.length;
    int randomTimes = size/10; //only change 10% of pixels
    size--;

    for (int i = 0; i < randomTimes; i++) {
        pixels[r.nextInt(size)]=r.nextInt();
    }
    long stopTime = System.currentTimeMillis();
    System.out.println("time "+(stopTime-startTime));
}
于 2013-06-28T14:13:16.893 回答