缓冲图像上的水滴形状

Question

我正在用Java开发一个简单的形状编辑器，我正在BufferedImage上绘制所有内容，因为我想保存绘制的图像。用户可以通过从菜单中选择形状来绘制形状，然后单击图像。我开始实现拖动形状。当我拖动一个形状时，正在创建该形状的路径...我认为是因为我在BufferedImage上绘制，所以就像“临时”一样。还是我错了？我当时想重新编写所有内容，这次不是在BufferedImage上绘图，而只是创建Graphics2D，但是我在实现侦听器时遇到了问题，因为我需要将我的Graphics2D转移到那里以在其中添加形状，而且我也不知道如何调用重绘在例如。我的MouseListener类。当用户想要保存图像时，我打算创建BufferedImage，我可以在存储所有形状的矢量的帮助下创建它（还是更好的方法？）。这是我的小组课程：

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);
    };
}

我做了很多阅读，但仍然无法正确完成，我需要调整形状，移动形状等，但是同时我想随后保存图像，

Answer 1

我要提出的解决方案还远远不能完成，但是我希望它能说明一些可以帮助您获得成功的概念。我将用两个可移动的图像构建一个面板，但是将使用使该代码更易于维护的模式来进行此操作。

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

[首先，请定义您出现在屏幕中的一个形状。我将保持非常简单，并使用位置，大小和BufferedImage创建一个：

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 );
            }
        }
    }
}

接下来，我们需要一种将形状/节点渲染到屏幕上的方法。每次调用paint(...)时，我们都可以绘制每个节点，但这并不是很有效，因为我们只需要重新绘制无效区域即可。通过确保JComponent使用双缓冲，我们可以不理会其余区域：https://docs.oracle.com/javase/7/docs/api/javax/swing/JComponent.html#setDoubleBuffered(boolean)

在Swing中用于完成此操作的一种常用技术是将CellRendererPane与用作渲染器的JLabel结合使用。每当我们需要在特定位置绘制节点时，我们都可以将所需的图像和大小分配给JLabel，并在绘制过程中（可能不止一次）在不同位置使CellRendererPane渲染该JLabel。

让我们创建这样的JLabel子类，并给它一个帮助器方法以初始化其从给定节点的状态：

class ShapeRenderer extends JLabel
{
    private static final long serialVersionUID = 1L;

    public ShapeRenderer() {
    }

    public void initFrom( DrawNode node )
    {
        setIcon( new ImageIcon( node.getImage() ));
        setSize( node.getBounds().getSize() );
    }

    // Methods below are overridden as a performance optimization:
    @Override
    public void invalidate() {
    }

    @Override
    public void validate() {
    }

    @Override
    public void revalidate() {
    }

    @Override
    public void repaint( long tm, int x, int y, int width, int height ) {
    }

    @Override
    public void repaint( Rectangle r ) {
    }

    @Override
    public void repaint() {
    }

    @Override
    protected void firePropertyChange( String propertyName, Object oldValue, Object newValue ) {
    }

    @Override
    public void firePropertyChange( String propertyName, boolean oldValue, boolean newValue ) {
    }
}

至此，我们剩下JComponent，让我们创建一个自定义的。我们给它一个DrawPanelModel，CellRendererPane和我们的ShapeRenderer。它将作为侦听器订阅模型，并在节点移动时响应区域中的模型无效而调用repaint(Rectangle)。请记住，repaint(...)立即进行绘制，而不是安排在将来的某个时间发生绘制事件。这意味着我们实际上可以移动多个节点，并且Swing框架将为我们提供一个绘画事件，该事件将所有无效矩形的并集指定为Graphic's剪辑区域。但是，我们的代码并不真正在乎是否合并无效区域。如果框架决定为我们使无效的每个区域提供绘画事件，我们也可以处理：

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 );
}

结果：