Java Applets：绘制彼此不重叠的圆吗？

Question

This program draws 10 circles, in a random position with a random diameter. If the circle's diameter is less than 25 it fills it yellow, more than 50, fills it green otherwise draws it red.

My problem is I cannot figure out how to stop the circles from overlapping one another.

This is what I've done so far:

import java.util.Random;
import java.awt.*;
import javax.swing.JApplet;

public class Circles extends JApplet{   

public void paint(Graphics g) {

    Random rand = new Random();
    int diameter = 0;
    int posX = 0;
    int posY = 0;

    setBackground(Color.CYAN);

    for(int i=1; i <= 5 ; i++ )
    {
        posX = rand.nextInt(500);
        posY = rand.nextInt(500);
        diameter = rand.nextInt(75)+1;

        if (diameter < 25)
        {
            g.setColor(Color.YELLOW);
            g.fillOval(posX, posY,diameter,diameter);
        }

        else if(diameter > 50)
        {
            g.setColor(Color.GREEN);
            g.fillOval(posX, posY,diameter,diameter);
        }
        else
        {
            g.setColor(Color.RED);
            g.drawOval(posX, posY,diameter,diameter);
        }


    }
}
}

Also if you notice my for loop only counts to 5 but I get 10 circles. I was just curious to know why that is?

Answer 1

There are several issues here.

• don't call setBackground(Color) in the paint method. This method is solely intended for painting. Other modifications should be done in the constructor or the init method
• Call super.paint(g) as the first line of your overridden paint method. This will clear the background
• (Minor: Make the scope of variables as small as possible. So declare posX etc. only where they are really needed )

Concerning the placement of the circles:

At the moment, you are computing new positions and diameters for the circles each time the applet is repainted . So when you resize the window of the applet viewer, new, randomly placed circles will flicker all around. You should create the circles only once (in the constructor, probably). In the paint method, you should only paint them.

More importantly: How to you know that it is possible to place the circles without overlaps? In the end, this leads into the complex world of Circle Packing where you may epmploy some really sophisticated techniques to make sure that you place the circles as tightly as possible.

But for now, you can use a very simple approach: Each time that you create a new circle, you can try (several times) to assign a new position and diameter, until you found a configuration that does not overlap an already existing circle. Although it may seem tempting to use a method like

while (existingCircles.size() < 5)
{
    Circle circle = newRandomCircle();
    if (!circle.overlapsAny(existingCircles))
    {
        existingCircles.add(circle);
    }
}

the problem here is that this algorithm will not terminate when it is not possible to place the circles at all! (Note: This is pseudocode. But ... you should consider writing your code in a way so that it looks like the code above. That is, consider creating a Circle class, for example).

However, here is a very pragmatic solution, that only tries to place a new circle for 10 times, and simply does not place it when it does not succeed. While this is not very elegant, it's at least guaranteed to terminate.

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JApplet;

public class Circles extends JApplet
{   
    private final List<Point> positions;
    private final List<Integer> diameters;

    public Circles()
    {
        positions = new ArrayList<Point>();
        diameters = new ArrayList<Integer>();

        Random rand = new Random();

        for(int i=1; i <= 5 ; i++ )
        {
            int tries = 10;
            for (int t=0; t<tries; t++)
            {
                int diameter = rand.nextInt(75)+1;
                int posX = rand.nextInt(500);;
                int posY = rand.nextInt(500);
                Point position = new Point(posX, posY);

                if (!overlapsOther(position, diameter))
                {
                    positions.add(new Point(posX, posY));
                    diameters.add(diameter);
                    break;
                }
            }
        }
    }

    private boolean overlapsOther(Point position, int diameter)
    {
        int radius = diameter/2;
        int centerX = position.x + radius;
        int centerY = position.y + radius;

        for (int i=0; i<positions.size(); i++)
        {
            Point otherPosition = positions.get(i);
            int otherDiameter = diameters.get(i);
            int otherRadius = otherDiameter/2;
            int otherCenterX = otherPosition.x + otherRadius;
            int otherCenterY = otherPosition.y + otherRadius;

            int dx = centerX - otherCenterX;
            int dy = centerY - otherCenterY;
            double distance = Math.hypot(dx, dy);
            if (distance < radius + otherRadius)
            {
                return true;
            }
        }
        return false;
    }

    @Override
    public void paint(Graphics g) 
    {
        super.paint(g);

        for(int i=0; i<positions.size(); i++)
        {
            int posX = positions.get(i).x;
            int posY = positions.get(i).y;
            int diameter = diameters.get(i);

            if (diameter < 25)
            {
                g.setColor(Color.YELLOW);
                g.fillOval(posX, posY,diameter,diameter);
            }

            else if(diameter > 50)
            {
                g.setColor(Color.GREEN);
                g.fillOval(posX, posY,diameter,diameter);
            }
            else
            {
                g.setColor(Color.RED);
                g.drawOval(posX, posY,diameter,diameter);
            }

            System.out.println(diameter);
        }
    }
}

Answer 2

To draw non-overlapping circles, you need to check if a new one would intersect one of the already defined circles.

1. Initialize an empty stack
2. Pick a random x,y, and radius (1/2 of your diameter).
3. Loop over the stack and use (simple!) maths to calculate the distance to the center of each of the other circles. If this distance is less than its radius + the new radius, it does not touch.
4. If it does, go to 2.
5. If it touches none of the other circles, add it to the stack.
6. If the length of the stack is less than 5, go to 2.
7. Loop over the stack and draw each circle.

You might want to add a #Tries counter to #2/3 -- eg, if it fails to find a good place for the fourth or fifth circle, it may loop forever. If the #Tries counter exceeds some limit, go to #1; essentially, start from scratch.