Java 缓冲图像上的可拖动形状

我正在用Java开发一个简单的形状编辑器，我在BuffereImage Science上绘制了所有的东西，我想保存绘制的图像。用户可以从菜单中选择形状，然后单击图像来绘制形状。我开始实现拖动形状。当我拖动一个形状时，将创建该形状的路径。。。我想这是因为我使用了BuffereImage，所以它就像“临时的”。还是我错了？我在考虑重写所有内容，这次不是在BuffereImage上绘制，只是创建Graphics2D，但我在实现侦听器时遇到了问题，因为我需要将Graphics2D传输到那里以在那里添加形状，而且我不知道如何调用repaint，例如我的MouseListener类。我计划在用户想要保存图像时创建BuffereImage，我会在vector的帮助下创建它，在这里我存储所有形状（或者是更好的方式？）。这是我的小组课：

public class Panel {

    public static Graphics2D img2;

    public static Graphics2D getIm() {
        return this.img2;
    }

    public Panel(JFrame frame) {

        JPanel panel = new JPanel(true) {

            @Override
            protected void paintComponent(Graphics g) {

                super.paintComponent(g);


                img2 = (Graphics2D)g.create();  
                img2.dispose();
            };
        };
        RenderingHints.VALUE_ANTIALIAS_ON); // setting rendering to achieve better looking shapes
        panel.setBackground(Color.WHITE);
        MouseListenerShapes mouseListenerShapes = new MouseListenerShapes();
        panel.addMouseListener(mouseListenerShapes);
        //MouseMoveAdapter mouseMouseMoveAdapter = new MouseMoveAdapter();
        //panel.addMouseMotionListener(mouseMouseMoveAdapter);
        //panel.addMouseListener(mouseMouseMoveAdapter);
        frame.add(panel);
    };
}

---

我读了很多书，但我仍然不能把它做对，我需要我的形状可以调整大小，可以移动，等等。但同时我想在以后保存图像，

我要提出的解决方案还远没有完成，但我希望它能说明一些概念，帮助你找到成功。我将用两个可移动的图像构建一个面板，但使用的模式应该使代码更易于维护

我强烈建议将渲染层（组件）和模型层（形状及其位置）分离为不同的对象。这被称为关注点分离，从长远来看，这将使你的生活更轻松

首先，让我们定义屏幕上显示的一个形状。我将保持我的非常简单，并创建一个具有位置、大小和

缓冲区图像的图像：

class DrawNode
{
    private Rectangle bounds;
    private BufferedImage image;

    public DrawNode()
    {
    }

    public Rectangle getBounds()
    {
        return bounds;
    }

    public void setBounds( Rectangle bounds )
    {
        this.bounds = bounds;
    }

    public BufferedImage getImage()
    {
        return image;
    }

    public void setImage( BufferedImage image )
    {
        this.image = image;
    }
}

接下来，让我们创建一个模型来保存形状集合。我们可以使用该模型做的一件巧妙的事情是让它接受一个监听器，该监听器将在2D空间的某个部分变得“无效”时被调用。如果某个节点以前位于给定区域，并且已移动到新区域，则该空间的某个部分可能会变得无效，并且需要重新绘制。我们还将包括一些辅助方法，用于确定什么形状占据给定空间等。这些辅助方法可以在效率方面进行极大优化，但我的简单版本将使用蛮力迭代：

class DrawPanelModel
{
    private final List<DrawNode> nodes;
    private final Consumer<Rectangle> invalidAreaListener;

    public DrawPanelModel( Consumer<Rectangle> invalidAreaListener )
    {
        this.invalidAreaListener = invalidAreaListener;
        nodes = new ArrayList<>();
    }

    public void addNode( DrawNode node )
    {
        nodes.add( node );
    }

    public Optional<DrawNode> getNodeForPoint( Point p )
    {
        return nodes.stream()
                .filter( node -> node.getBounds().contains( p ))
                .findFirst();
    }

    public Stream<DrawNode> getNodesInRectangle( Rectangle r )
    {
        return nodes.stream()
                .filter( node -> node.getBounds().intersects( r ));
    }

    public void setNodeLocation( DrawNode node, Point p )
    {
        Rectangle bounds = (Rectangle)node.getBounds().clone();
        bounds.setLocation( p );
        setNodeBounds( node, bounds );
    }

    public void setNodeBounds( DrawNode node, Rectangle bounds )
    {
        Rectangle old = node.getBounds();
        node.setBounds( Objects.requireNonNull( bounds ));

        if ( old == null || !old.equals( bounds ))
        {
            invalidAreaListener.accept( bounds );

            if ( old != null ) {
                invalidAreaListener.accept( old );
            }
        }
    }
}

现在我们剩下
JComponent
，让我们创建一个自定义组件。我们将为它提供一个
DrawPanelModel
，
cellrenderpane
，以及我们的
shaperender
。它将作为侦听器订阅模型，调用
repaint（Rectangle）
，以响应节点移动时模型在区域中失效。请记住，
重新绘制（…）
不会立即绘制，而是将绘制事件安排在未来某个时间点发生。这意味着我们实际上可以移动多个节点，Swing框架将为我们提供一个绘制事件，该事件将所有无效矩形的并集指定为
图形的
剪辑区域。但是，我们的代码并不真正关心是否合并了无效区域。如果框架决定为我们失效的每个区域提供绘画活动，我们也可以处理：

class DrawPanel extends JComponent
{
    private static final long serialVersionUID = 1L;

    private final CellRendererPane renderPane;
    private final ShapeRenderer renderer;
    private final DrawPanelModel model;

    public DrawPanel()
    {
        renderPane = new CellRendererPane();
        add( renderPane );
        setDoubleBuffered( true );
        renderer = new ShapeRenderer();
        model = new DrawPanelModel( this::repaint );

        DrawMouseListener listener = new DrawMouseListener();
        addMouseListener( listener );
        addMouseMotionListener( listener );
    }

    public void addNode( BufferedImage image, Point loc )
    {
        DrawNode node = new DrawNode();
        node.setImage( image );
        model.addNode( node );
        model.setNodeBounds( node, new Rectangle( loc, new Dimension( image.getWidth(), image.getHeight() )));
    }

    @Override
    public void doLayout()
    {
        renderPane.setSize( getSize() );
    }

    private void paintBackground( Graphics2D g )
    {
        g.setColor( Color.WHITE );
        g.fill( g.getClip() );
    }

    private void paintNodes( Graphics2D g )
    {
        model.getNodesInRectangle( g.getClipBounds() )
            .forEach( node -> paintNode( node, g ));
    }

    private void paintNode( DrawNode node, Graphics2D g )
    {
        Rectangle r = node.getBounds();
        renderer.initFrom( node );
        renderPane.paintComponent( g, renderer, this, r );
    }

    @Override
    public void paintComponent( Graphics aG )
    {
        Graphics2D g = (Graphics2D)aG.create();
        paintBackground( g );
        paintNodes( g );
    }

    class DrawMouseListener extends MouseAdapter
    {
        private Optional<DrawNode> movingNode;

        public DrawMouseListener()
        {
            movingNode = Optional.empty();
        }

        @Override
        public void mousePressed( MouseEvent e )
        {
            movingNode = model.getNodeForPoint( e.getPoint() );
        }

        @Override
        public void mouseReleased( MouseEvent e )
        {
            movingNode = Optional.empty();
        }

        @Override
        public void mouseDragged( MouseEvent e )
        {
            movingNode.ifPresent( node -> {
                model.setNodeLocation( node, e.getPoint() );
            } );
        }
    }
}

结果:


class DrawPanel extends JComponent
{
    private static final long serialVersionUID = 1L;

    private final CellRendererPane renderPane;
    private final ShapeRenderer renderer;
    private final DrawPanelModel model;

    public DrawPanel()
    {
        renderPane = new CellRendererPane();
        add( renderPane );
        setDoubleBuffered( true );
        renderer = new ShapeRenderer();
        model = new DrawPanelModel( this::repaint );

        DrawMouseListener listener = new DrawMouseListener();
        addMouseListener( listener );
        addMouseMotionListener( listener );
    }

    public void addNode( BufferedImage image, Point loc )
    {
        DrawNode node = new DrawNode();
        node.setImage( image );
        model.addNode( node );
        model.setNodeBounds( node, new Rectangle( loc, new Dimension( image.getWidth(), image.getHeight() )));
    }

    @Override
    public void doLayout()
    {
        renderPane.setSize( getSize() );
    }

    private void paintBackground( Graphics2D g )
    {
        g.setColor( Color.WHITE );
        g.fill( g.getClip() );
    }

    private void paintNodes( Graphics2D g )
    {
        model.getNodesInRectangle( g.getClipBounds() )
            .forEach( node -> paintNode( node, g ));
    }

    private void paintNode( DrawNode node, Graphics2D g )
    {
        Rectangle r = node.getBounds();
        renderer.initFrom( node );
        renderPane.paintComponent( g, renderer, this, r );
    }

    @Override
    public void paintComponent( Graphics aG )
    {
        Graphics2D g = (Graphics2D)aG.create();
        paintBackground( g );
        paintNodes( g );
    }

    class DrawMouseListener extends MouseAdapter
    {
        private Optional<DrawNode> movingNode;

        public DrawMouseListener()
        {
            movingNode = Optional.empty();
        }

        @Override
        public void mousePressed( MouseEvent e )
        {
            movingNode = model.getNodeForPoint( e.getPoint() );
        }

        @Override
        public void mouseReleased( MouseEvent e )
        {
            movingNode = Optional.empty();
        }

        @Override
        public void mouseDragged( MouseEvent e )
        {
            movingNode.ifPresent( node -> {
                model.setNodeLocation( node, e.getPoint() );
            } );
        }
    }
}

@Test
public void testPanel() throws InvocationTargetException, InterruptedException
{
    SwingUtilities.invokeLater( () -> {

        // Create frame:
        JFrame frame = new JFrame();
        frame.setLayout( new GridLayout( 1, 1 ));

        // Create draw panel:
        DrawPanel drawPanel = new DrawPanel();
        frame.add( drawPanel );

        // Show frame:
        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        frame.setSize( new Dimension( 1000, 600 ));
        frame.setVisible( true );

        // Create first image:
        BufferedImage image1 = new BufferedImage( 50, 50, BufferedImage.TYPE_INT_ARGB );
        Graphics2D g = image1.createGraphics();
        g.setColor( Color.BLUE );
        g.fillOval( 0, 0, 50, 50 );

        // Add first image to draw panel:
        drawPanel.addNode( image1, new Point( 100, 100 ));

        // Create second image:
        BufferedImage image2 = new BufferedImage( 50, 50, BufferedImage.TYPE_INT_ARGB );
        Graphics2D g2 = image2.createGraphics();
        g2.setColor( Color.RED );
        g2.fillOval( 0, 0, 50, 50 );

        // Add second image to draw panel:
        drawPanel.addNode( image2, new Point( 200, 100 ));
    } );

    Thread.sleep( Long.MAX_VALUE );
}