java Swing 图片缓冲机制

时间：2022-02-18 09:19:04

java Swing 图片缓冲机制：

参考：http://jorneyr.iteye.com/blog/868858#comments

package util;

import java.awt.geom.Point2D;

public class GeometryUtil {

    // 两点之间的距离

    public static double distanceOfPoints(Point2D p1, Point2D p2) {

        double disX = p2.getX() - p1.getX();

        double disY = p2.getY() - p1.getY();

        double dis = Math.sqrt(disX * disX + disY * disY);

        return dis;

    }

    // 两点的中点

    public static Point2D middlePoint(Point2D p1, Point2D p2) {

        double x = (p1.getX() + p2.getX()) / 2;

        double y = (p1.getY() + p2.getY()) / 2;

        return new Point2D.Double(x, y);

    }

    // 在两点所在直线上，以从startPoint到endPoint为方向，离startPoint的距离disToStartPoint的点

    public static Point2D extentPoint(Point2D startPoint, Point2D endPoint, double disToStartPoint) {

        double disX = endPoint.getX() - startPoint.getX();

        double disY = endPoint.getY() - startPoint.getY();

        double dis = Math.sqrt(disX * disX + disY * disY);

        double sin = (endPoint.getY() - startPoint.getY()) / dis;

        double cos = (endPoint.getX() - startPoint.getX()) / dis;

        double deltaX = disToStartPoint * cos;

        double deltaY = disToStartPoint * sin;

        return new Point2D.Double(startPoint.getX() + deltaX, startPoint.getY() + deltaY);

    }

    // 绕原点的旋转矩阵，绕任意点旋转，可以先移动到原点，旋转，然后再移回去

    // cosθ -sinθ 0

    // sinθ +conθ 0

    // 0000 +0000 1

    // x = r*cosα, y = r*sinα

    // x' = r*cos(α+θ) = r*cosα*cosθ - r*sinα*sinθ = x*cosθ - y*sinθ

    // y' = r*sin(α+θ) = r*sinα*cosθ + r*cosα*sinθ = x*sinθ + y*cosθ

    // (x, y)绕圆心旋转degree度

    public static Point2D rotate(double x, double y, double degree) {

        return rotate(x, y, 0, 0, degree);

    }

    // (x, y)绕(ox, oy)旋转degree度

    public static Point2D rotate(double x, double y, double ox, double oy, double degree) {

        x -= ox;

        y -= oy;

        double cos = Math.cos(Math.toRadians(degree));

        double sin = Math.sin(Math.toRadians(degree));

        double temp = x * cos - y * sin;

        y = x * sin + y * cos;

        x = temp;

        return new Point2D.Double(x + ox, y + oy);

    }

    public static void main(String[] args) {

        Point2D p = rotate(50, 10, 10);

        System.out.println(p);

        p = rotate(100, 60, 50, 50, 10);

        System.out.println(p);

    }

}
import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GraphicsConfiguration;

import java.awt.GraphicsDevice;

import java.awt.GraphicsEnvironment;

import java.awt.RenderingHints;

import java.awt.Transparency;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import util.GeometryUtil;

@SuppressWarnings("serial")

public class Growing extends JPanel {

    private List<Point2D> ps = new ArrayList<Point2D>();

    private Timer timer;

    private boolean stopped = false;

    public Growing() {

        ps.add(new Point2D.Double(0, 0));

        ps.add(new Point2D.Double(800, 0));

        timer = new Timer(500, new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                grow();

                repaint();

            }

        });

        timer.start();

    }

    public void grow() {

        if (stopped) {

            return;

        }

        List<Point2D> temp = new ArrayList<Point2D>();

        temp.add(ps.get(0));

        for (int i = 0; i < ps.size() - 1; ++i) {

            Point2D p0 = ps.get(i);

            Point2D p4 = ps.get(i + 1);

            double len = GeometryUtil.distanceOfPoints(p0, p4);

            if (len < 0.02) {

                // 当线条长度小于1时，就停止再增长

                System.out.println(ps.size());

                timer.stop();

                return;

            }

            Point2D p1 = GeometryUtil.extentPoint(p0, p4, len / 3);

            Point2D p3 = GeometryUtil.extentPoint(p0, p4, len * 2 / 3);

            Point2D p2 = GeometryUtil.rotate(p3.getX(), p3.getY(), p1.getX(), p1.getY(), 60);

            temp.add(p1);

            temp.add(p2);

            temp.add(p3);

            temp.add(p4);

        }

        // 将增长的计算结果赋予ps变量；

        ps = null;

        ps = temp;

        temp = null;

    }

    int i = 0; // 记录绘制了几次；

    @Override

    protected void paintComponent(Graphics g) {

        super.paintComponent(g);

        Graphics2D g2d = (Graphics2D) g;

        // 修改type的值使用不同的绘制方式，1为compatible image, 2为swing的back-buffer

        int type = 2;

        // 改变窗口的大小，可以看到直接对intermediate image操作比直接对swing back-buffer操作快很多.

        // 所以有很多绘制操作时，使用triple buffer是很有必要的(因为Swing已经默认使用了双缓冲).

        if (type == 1) {

            // [[[1]]]: 操作 compatible image 速度非常快

            renderWithBuf(g2d, getWidth(), getHeight());

        } else {

            // [[[2]]]: 操作Swing的 back-buffer 速度非常慢

            render(g2d, getWidth(), getHeight());

        }

        System.out.println("Growing.paintComponent(Graphics):" + i++);

    }

    private BufferedImage bufImg;

    protected void renderWithBuf(Graphics2D g2d, int w, int h) {

        if (bufImg == null || bufImg.getWidth() != w || bufImg.getHeight() != h) {

            bufImg = createCompatibleImage(w, h, Transparency.OPAQUE);

            // bufImg = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

        }

        Graphics2D gg = bufImg.createGraphics();

        render(gg, w, h);

        gg.dispose();

        g2d.drawImage(bufImg, 0, 0, null);

    }

    protected void render(Graphics2D g2d, int w, int h) {

        g2d.setBackground(Color.BLACK);

        g2d.clearRect(0, 0, w, h);

        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        g2d.translate(0, h - 20);

        g2d.setColor(Color.WHITE);

        for (int i = 0; i < ps.size() - 1; ++i) {

            Point2D sp = ps.get(i);

            Point2D ep = ps.get(i + 1);

            g2d.drawLine((int) sp.getX(), -(int) sp.getY(), (int) ep.getX(), -(int) ep.getY());

        }

    }

    // 创建硬件适配的缓冲图像，为了能显示得更快速

    public static BufferedImage createCompatibleImage(int w, int h, int type) {

        GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();

        GraphicsDevice device = env.getDefaultScreenDevice();

        GraphicsConfiguration gc = device.getDefaultConfiguration();

        return gc.createCompatibleImage(w, h, type);

    }

    private static void createGuiAndShow() {

        JFrame frame = new JFrame("Growing");

        frame.getContentPane().add(new Growing());

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.setSize(800, 400);

        frame.setAlwaysOnTop(true);

        frame.setLocationRelativeTo(null);

        frame.setVisible(true);

    }

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                createGuiAndShow();

            }

        });

    }

}
import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.graphics.Transform;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Canvas;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import util.GeometryUtil;

public class GrowingSWT

{

    private final Shell shell;

    private final Canvas canvas;

    private List<Point2D> ps = new ArrayList<Point2D>();

    private boolean stopped = false;

    Image image = null;

    int type = 1;

    private final Runnable timer = new Runnable() {

        public void run()

        {

            shell.getDisplay().timerExec(500, timer);

            grow();

            canvas.redraw();

        }

    };

    GrowingSWT(final Display display)

    {

        shell = new Shell(display, SWT.DOUBLE_BUFFERED | SWT.SHELL_TRIM);

        shell.setLayout(new FillLayout());

        canvas = new Canvas(shell, SWT.NULL);

        canvas.addPaintListener(new PaintListener() {

            public void paintControl(PaintEvent e)

            {

                long time = System.currentTimeMillis();

                if (type == 1) {

                    e.gc.drawImage(getBuffer(false), 0, 0);

                } else {

                    render(e.gc);

                }

                time = System.currentTimeMillis() - time;

                if (time > 10) {

                    System.out.println(time);

                }

            }

        });

        ps.add(new Point2D.Double(0, 0));

        ps.add(new Point2D.Double(800, 0));

        display.timerExec(500, timer);

    }

    Image getBuffer( boolean withRefresh)

    {

        Rectangle bounds = canvas.getBounds();

        if (image == null || !image.getBounds().equals(bounds)) {

            image = new Image(shell.getDisplay(), bounds);

            renderWithBuffer(image);

        } else if (withRefresh) {

            renderWithBuffer(image);

        }

        return image;

    }

    public void grow()

    {

        if (stopped) {

            return;

        }

        List<Point2D> temp = new ArrayList<Point2D>();

        temp.add(ps.get(0));

        for (int i = 0; i < ps.size() - 1; ++i) {

            Point2D p0 = ps.get(i);

            Point2D p4 = ps.get(i + 1);

            double len = GeometryUtil.distanceOfPoints(p0, p4);

            if (len < 0.1) {

                // 当线条长度小于1时，就停止再增长

                System.out.println(ps.size());

                shell.getDisplay().timerExec(-1, timer);

                return;

            }

            Point2D p1 = GeometryUtil.extentPoint(p0, p4, len / 3);

            Point2D p3 = GeometryUtil.extentPoint(p0, p4, len * 2 / 3);

            Point2D p2 = GeometryUtil.rotate(p3.getX(), p3.getY(), p1.getX(), p1.getY(), 60);

            temp.add(p1);

            temp.add(p2);

            temp.add(p3);

            temp.add(p4);

        }

        ps = null;

        ps = temp;

        temp = null;

        if (type == 1) {

            getBuffer(true);

        }

    }

    private void renderWithBuffer(Image image)

    {

        GC _gc = new GC(image);

        render(_gc);

        _gc.dispose();

    }

    private void render(GC gc)

    {

        Display display = shell.getDisplay();

        gc.setBackground(display.getSystemColor(SWT.COLOR_BLACK));

        Rectangle bounds = canvas.getBounds();

        gc.fillRectangle(bounds);

        gc.setAdvanced(true);

        gc.setAntialias(SWT.ON);

        Transform transform = new Transform(display);

        transform.translate(0, bounds.height - 20);

        gc.setTransform(transform);

        gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE));

        for (int i = 0; i < ps.size() - 1; ++i) {

            Point2D sp = ps.get(i);

            Point2D ep = ps.get(i + 1);

            gc.drawLine((int) sp.getX(), -(int) sp.getY(), (int) ep.getX(), -(int) ep.getY());

        }

    }

    public static void main(String[] args)

    {

        Display display = Display.getDefault();

        Shell shell = new GrowingSWT(display).shell;

        shell.setSize(800, 400);

        shell.open();

        while (!shell.isDisposed()) {

            if (!display.readAndDispatch()) {

                display.sleep();

            }

        }

    }

}

相关文章