Java algorithm to declutter rectangles

Not much of a code review, too long for a comment - suggestion:

Do a line sweep over your (iso-oriented ("axis-parallel")?) rectangles computing "vertical" and "horizontal" scales sufficient to declutter them as needed. (With identical y-coordinates or enclosure, adjust x-scaling and vice-versa. With overlap or enclosure in both directions, main concerns are current scales and relative amount of overlap. With identical mid-point, you're screwed.)
Scale everything as computed, eyeball the result and refine your requirement description.

Not an algorithm review, but rather a review from software engineering point of view.

Advice 1

List<Rectangle2D> rectangles = new ArrayList<Rectangle2D>();

I suggest you use diamond inference:

List<Rectangle2D> rectangles = new ArrayList<>();

Advice 2

I also suggest you declare rectangles above as private final:

private final List<Rectangle2D> rectangles = new ArrayList<>();

Advice 3

List<Rectangle2D> rectanglesToDraw;

I would add private here too.

Advice 4

In findIntersections, you have:

ArrayList<Rectangle2D> intersections = new ArrayList<Rectangle2D>();

Better write this as

List<Rectangle2D> intersections = new ArrayList<>();

This adds up to maintainability of your code, say, if someone else wants to use a LinkedList instead.

Advice 5

surroundingRect can be written much shorter:

private Rectangle2D surroundingRect(List<Rectangle2D> rectangles) {

        Point topLeft = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE);
        Point bottomRight = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE);

        for (Rectangle2D rect : rectangles) {
            topLeft.x = Math.min(topLeft.x, (int) rect.getMinX());
            topLeft.y = Math.min(topLeft.y, (int) rect.getMinY());
            bottomRight.x = Math.max(bottomRight.x, (int) rect.getMaxX());
            bottomRight.y = Math.max(bottomRight.y, (int) rect.getMaxY());
        }

        return new Rectangle2D.Double(topLeft.getX(), 
                                      topLeft.getY(), 
                                      bottomRight.getX() - topLeft.getX(),
                                      bottomRight.getY() - topLeft.getY());
    }

Advice 6

Rename Rectangles the JPanel to, say, RectangleViewPanel.

Advice 7

This is most important. I suggest you decouple GUI from the actual algorithm. You could come up with an abstract class/interface that defines the API for rectangle declutter algorithms, and derive from it for each actual algorithm. Your code may look like this (just an example):

AbstractRectangleDeclutter.java

import java.awt.Point;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;

public abstract class AbstractRectangleDeclutter {

    public abstract List<Rectangle2D> declutter(List<Rectangle2D> rectangles);

    protected List<Rectangle2D> copy(List<Rectangle2D> rectangles) { 
        List<Rectangle2D> newRectangles = new ArrayList<>(rectangles.size());

        for (Rectangle2D rectangle : rectangles) {
            Rectangle2D newRectangle = new Rectangle2D.Double();
            newRectangle.setRect(rectangle);
            newRectangles.add(newRectangle);
        }

        return newRectangles;
    }

    protected Rectangle2D 
        findSurroundingRectangle(List<Rectangle2D> rectangles) {
        Point topLeft = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE);
        Point bottomRight = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE);

        for (Rectangle2D rect : rectangles) {
            topLeft.x = Math.min(topLeft.x, (int) rect.getMinX());
            topLeft.y = Math.min(topLeft.y, (int) rect.getMinY());
            bottomRight.x = Math.max(bottomRight.x, (int) rect.getMaxX());
            bottomRight.y = Math.max(bottomRight.y, (int) rect.getMaxY());
        }

        return new Rectangle2D.Double(topLeft.getX(), 
                                      topLeft.getY(), 
                                      bottomRight.getX() - topLeft.getX(),
                                      bottomRight.getY() - topLeft.getY());
    }

    protected List<Rectangle2D>
         findIntersectingRectangles(Rectangle2D rectangle,
                                    List<Rectangle2D> otherRectangles) {
        List<Rectangle2D> intersectingRectangles = new ArrayList<>();

        for (Rectangle2D otherRectangle : otherRectangles) {
            if (!rectangle.equals(otherRectangle) 
                    && rectangle.intersects(otherRectangle)) {
                intersectingRectangles.add(otherRectangle);
            }
        }

        return intersectingRectangles;
    }
}

DefaultRectangleDeclutter.java

import java.awt.Point;
import java.awt.geom.Rectangle2D;
import java.util.List;

public class DefaultRectangleDeclutter extends AbstractRectangleDeclutter {

    private static final int MOVEMENT_FACTOR = 10;

    private int numberOfIterations;

    @Override
    public List<Rectangle2D> declutter(List<Rectangle2D> inputRectangles) {
        numberOfIterations = 0;

        List<Rectangle2D> outputRectangles = copy(inputRectangles);
        Rectangle2D surroundingRectangle = 
               findSurroundingRectangle(inputRectangles);

        Point center = new Point((int) surroundingRectangle.getCenterX(),
                                 (int) surroundingRectangle.getCenterY());

        boolean hasIntersections;

        do {
            hasIntersections = false;

            for (Rectangle2D rectangle : outputRectangles) {
                List<Rectangle2D> intersectingRectangles = 
                        findIntersectingRectangles(rectangle, outputRectangles);

                if (!intersectingRectangles.isEmpty()) {
                    Point movementVector = new Point();
                    Point centerOfRectangle = 
                            new Point((int) rectangle.getCenterX(),
                                      (int) rectangle.getCenterY());

                    for (Rectangle2D intersectingRectangle 
                            : intersectingRectangles) {
                        Point centerOfIntersectingRectangle = 
                            new Point((int) intersectingRectangle.getCenterX(),
                                      (int) intersectingRectangle.getCenterY());

                        int xTranslation = 
                                (int)(centerOfRectangle.getX() - 
                                      centerOfIntersectingRectangle.getX());

                        int yTranslation =
                                (int)(centerOfRectangle.getY() - 
                                      centerOfIntersectingRectangle.getY());

                        movementVector.translate(
                                xTranslation < 0 ?
                                        -MOVEMENT_FACTOR :
                                         MOVEMENT_FACTOR,
                                yTranslation < 0 ?
                                        -MOVEMENT_FACTOR :
                                         MOVEMENT_FACTOR);
                    }

                    int xTranslation = (int)(centerOfRectangle.getX() -
                                             center.getX());

                    int yTranslation = (int)(centerOfRectangle.getY() -
                                             center.getY());

                    movementVector.translate(
                            xTranslation < 0 ? 
                                    -MOVEMENT_FACTOR :
                                     MOVEMENT_FACTOR,
                            yTranslation < 0 ?
                                    -MOVEMENT_FACTOR :
                                     MOVEMENT_FACTOR);

                    rectangle.setRect(
                        rectangle.getX() + movementVector.getX(),
                        rectangle.getY() + movementVector.getY(),
                        rectangle.getWidth(),
                        rectangle.getHeight());

                    hasIntersections = true;
                }
            }

            numberOfIterations++;
        } while (hasIntersections);

        return outputRectangles;
    }

    public int getNumberOfIterations() {
        return numberOfIterations;
    }
}

RectangleViewPanel.java

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Rectangle2D;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class RectangleViewPanel extends JPanel {

    private List<Rectangle2D> rectangleList;

    public List<Rectangle2D> getRectangleList() {
        return this.rectangleList;
    }

    public void setRectangleList(List<Rectangle2D> rectangleList) {
        this.rectangleList = rectangleList;
        repaint();
    }

    //Draws the rectangles in the frame from the rectanglesToDraw data structure  
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;

        if (rectangleList != null) {
            for (Rectangle2D entry : rectangleList) {
                g2d.setStroke(new BasicStroke(1));
                g2d.draw(entry);
            }
        }
    }

    //create GUI components and display it to the user
    protected static void createAndShowGUI() {
        RectangleViewPanel rects = new RectangleViewPanel();
        rects.setRectangleList(getRectangles());

        JFrame frame = new JFrame("Rectangles");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());
        frame.add(rects, BorderLayout.CENTER);

        JPanel buttonsPanel = new JPanel();

        JButton fix = new JButton("Fix");

        fix.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                AbstractRectangleDeclutter declutter = 
                        new DefaultRectangleDeclutter();

                long start = System.currentTimeMillis();
                List<Rectangle2D> newRectangles =
                        declutter.declutter(rects.getRectangleList());
                long end = System.currentTimeMillis();

                rects.setRectangleList(newRectangles);
                rects.repaint();

                System.out.println(
                        "That took "+ 
                                TimeUnit.MILLISECONDS
                                        .convert(end - start, 
                                                 TimeUnit.MILLISECONDS)
                                + " milliseconds.");
            }
        });

        JButton resetButton = new JButton("Reset");

        resetButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                rects.setRectangleList(getRectangles());
                rects.repaint();
            }
        });

        buttonsPanel.add(fix);
        buttonsPanel.add(resetButton);

        frame.add(buttonsPanel, BorderLayout.SOUTH);

        frame.setSize(1920, 900);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

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

            @Override
            public void run() {
                createAndShowGUI();
            }
        });
    }

    private static List<Rectangle2D> getRectangles() {
        List<Rectangle2D> rectangles = new ArrayList<>();

        rectangles.add(new Rectangle2D.Float(300, 50, 50, 50));
        rectangles.add(new Rectangle2D.Float(300, 50, 20, 50));
        rectangles.add(new Rectangle2D.Float(100, 100, 100, 50));
        rectangles.add(new Rectangle2D.Float(120, 200, 50, 50));
        rectangles.add(new Rectangle2D.Float(150, 130, 100, 100));
        rectangles.add(new Rectangle2D.Float(0, 100, 100, 50));
        rectangles.add(new Rectangle2D.Float(690, 229, 388, 114));
        rectangles.add(new Rectangle2D.Float(347, 341, 347, 425));
        rectangles.add(new Rectangle2D.Float(107, 515, 179, 158));
        rectangles.add(new Rectangle2D.Float(55, 487, 174, 153));
        rectangles.add(new Rectangle2D.Float(458, 553, 125, 128));
        rectangles.add(new Rectangle2D.Float(109, 566, 125, 128));
        rectangles.add(new Rectangle2D.Float(138, 166, 125, 128));

        int numRowsAndColumns = 20;

        // Add more rectangles
        for (int i = 0; i < numRowsAndColumns; i++) {
            for (int j = 0; j < numRowsAndColumns; j++) {
                rectangles.add(new Rectangle2D.Float(i * 20, j * 10, 25, 20));
            }
        }

        return rectangles;
    }
}

Bad advice 1

I guess greybeard knows better about computational geometry, yet, as a novice, I would do the next: sort all the rectangles by area. Then start laying them out from left to right to the top of the panel. When the first "row" is occupied, lay the next "row" from right to left, and so on.

Actually, I suspect that optimal layout minimizing the surrounding area is very hard to compute (NP-hard or something).

Hope that helps.