Positioning squares on a circle with minimum diameter_问答_开发者

Given n squares with edge length l, how can I determine the minimum radius r of the circle so that I can distribute all squares evenly along the perimeter of the circle without them overlapping? (Constraint: the first square will always be positioned at 12 o'clock.)

Followup questi开发者_如何学运维on: how can I place n identical rectangles with height h and width w?

Positioning squares on a circle with minimum diameter

_{(source: n3rd.org)}

There may be a mathematically clever way to do this, but I wouldn't know. I think it's complicated a bit by the fact that the geometry is different for every different number of squares; for 4 it's a rhombus, for 5 it's a pentagon and so on.

What I'd do is place those squares on a 1 unit circle (much too small, I know, bear with me) distributed equally on it. That's easy enough, just subtend (divide) your 360 degrees by the number of squares. Then just test all your squares for overlap against their neighbors; if they overlap, increase the radius.

You can make this procedure less stupid than it sounds by using an intelligent algorithm to approach the right size. I'm thinking of something like Newton's algorithm: Given two successive guesses, of which one is too small and one is too big, your next guess needs to be the average of those two.

~~You can iterate down to any precision you like. Stop whenever the distance between guesses is smaller than some arbitrary small margin of error.~~

EDIT I have a better solution:

I was thinking about what to tell you if you asked "how will I know if squares overlap?" This gave me an idea on how to calculate the circle size exactly, in one step:

Place your squares on a much-too-small circle. You know how: Calculate the points on the circle where your 360/n angles intersect it, and put the center of the square there. Actually, you don't need to place squares yet, the next steps only require midpoints.

To calculate the minimum distance of a square to its neighbor: Calculate the difference in X and the difference in Y of the midpoints, and take the minimum of those. The X's and Y's are actually just cosines and sines on the circle.

You'll want the minimum of any square against its neighbor (clockwise, say). So you need to work your way around the circle to find the very smallest one.

The minimum (X or Y) distance between the squares needs to become 1.0 . So just take the reciprocal of the minimum distance and multiply the circle's size by that. Presto, your circle is the right size.

EDIT

Without losing generality, I think it's possible to nail my solution down a bit so it's close to coding. Here's a refinement:

Assume the squares have size 1, i.e. each side has a length of 1 unit. In the end, your boxes will surely be larger than 1 pixel but it's just a matter of scaling.

Get rid of the corner cases:

if (n < 2) throw new IllegalArgumentException();
if (n == 2) return 0.5; // 2 squares will fit exactly on a circle of radius 0.5

Start with a circle size r of 0.5, which will surely be too small for any number of squares > 2.

r = 0.5;
dmin = 1.0; // start assuming minimum distance is fine
a = 2 * PI / n;
for (p1 = 0.0; p1 <= PI; p1+=a) { // starting with angle 0, try all points till halfway around
   // (yeah, we're starting east, not north. doesn't matter)
   p2 = p1 + a; // next point on the circle 
   dx = abs(r * cos(p2) - r * cos(p1))
   dy = abs(r * sin(p2) - r * sin(p1))
   dmin = min(dmin, dx, dy)
}

r = r / dmin;

EDIT

I turned this into real Java code and got something quite similar to this to run. Code and results here: http://ideone.com/r9aiu

I created graphical output using GnuPlot. I was able to create simple diagrams of boxes arranged in a circle by cut-and-pasting the point sets from the output into a data file and then running

plot '5.dat' with boxxyerrorbars

The .5's in the file serve to size the boxes... lazy but working solution. The .5 is applied to both sides of the center, so the boxes end up being exactly 1.0 in size.

Alas, my algorithm doesn't work. It makes the radii far too large, thus placing the boxes much further apart than necessary. Even scaling down by a factor of 2 (could have been a mistake to use 0.5 in some places) didn't help.

~~Sorry, I give up. Maybe my approach can be salvaged, but it doesn't work the way I had though it would. :(~~

EDIT

I hate giving up. I was about to leave my PC when I thought of a way to salvage my algorithm:

The algorithm was adjusting the smaller of the X or Y distances to be at least 1. It's easy to demonstrate that's just plain silly. When you have a lot of boxes then at the eastern and western edges of the circle you have boxes stacked almost directly on top of each other, with their X's very close to one another but they are saved from touching by having just enough Y distance between them.

So... to make this work, you must scale the maximum of dx and dy to be (for all cases) at least the radius (or was it double the radius?).

Corrected code is here: ~~http://ideone.com/EQ03g~~ http://ideone.com/VRyyo

Tested again in GnuPlot, it produces beautiful little circles of boxes where sometimes just 1 or 2 boxes are exactly touching. Problem solved! :)

Positioning squares on a circle with minimum diameter

(These images are wider than they are tall because GnuPlot didn't know I wanted proportional layout. Just imagine the whole works squeezed into a square shape :) )

I would calculate an upper bound of the minimum radius, by working with circles enclosing the squares instead of with the squares themselves.

My calculation results in:

Rmin <= X / (sqrt(2) * sin (180/N) )

Where: X is the square side length, and N is the required number of squares.

I assume that the circles are positioned such that their centers fall on the big circle's circumference.

-- EDIT --

Using the idea of Dave in the comment below, we can also calculate a nice lower bound, by considering the circles to be inside the squares (thus having radius X/2). This bound is:

Rmin >= X / (2 * sin (180/N) )

As already noted, the problem of positioning n points equally spaced round the circumference of a circle is trivial. The (not-terribly) difficult part of the problem is to figure out the radius of the circle needed to give a pleasing layout of the squares. I suggest you follow one of the other answers and think of the squares being inside a circular 'buffer' big enough to contain the square and enough space to satisfy your aesthetic requirements. Then check the formula for the chord length between the centres of neighbouring squares. Now you have the angle, at the centre of the circle, subtended by the chord between square centres, and can easily compute the radius of the circle from the trigonometry of a triangle.

And, as to your follow up question: I suggest that you work out the problem for squares of side length min(h,w) on a circle, then transform the squares to rectangles and the circle to an ellipse with eccentricity h/w (or w/h).

I would solve it like this:

To find the relation between the radius r and length l let's analyze dimensionless representation

get the centres on a circle (x1,y1)..(xn,yn)
from each center get lower right corner of the i-th square and upper left corner of the i+1-th square
the two points should either have equal x or equal y, whichever yields smaller l
procedure should be repeated for each center and the one that yields smallest l is the final solution.

This is the optimal solution and can be solved it terms of r = f(l). The solution can be adapted to rectangles by adjusting the formula for xLR[i] and yUL[i+1].

Will try to give some pseudo code.

EDIT:
There's a bug in the procedure, lower right and upper left are not necessary closest points for two neighbouring squares/rectangles.

Let's assume you solved the problem for 3 or 4 squares.

If you have n >= 5 squares, and position one square at the top of the circle, you'll have another square fall into the first quadrant of a cartesian plane concentric with your circle.

The problem is then to find a radius r for the circle such that the left side of the circle next to the top one, and the right side of the top circle do not 'cross' each other.

The x coordinate of the right side of the top circle is x1 = L/2, where L is the side of a square. The x coordinate of the left side of the circle next to the top one is x2 = r cos a - L/2, where r is the radius and a is the angle between each pair of square centres (a = 360/n degrees).

So we need to solve x1 <= x2, which leads to

r >= L / cos a.

L and a are known, so we're done :-)

You start with an arbitrary circle (e.g., with a diameter of (* n l)) and position the squares evenly on the circumference. Then you go through each pair of adjacent squares and:

calculate the straight line connecting their mid points,

calculate the intersection of this line with the intervening square sides (M1 and M2 are the mid points, S1 and S2 the corresponding intersections with the square side:

                S2         S1
M1--------------*----------*---------------M2

------------------------
|                      |
|                      |
|                      |
|                      |
|          M1          |
|           \          |
|            \         |
|      -------*------- +--------
|      |       \       |       |
|      |        \      |       |
-------+---------*------       |
       |          \            |
       |           M2          |
       |                       |
       |                       |
       |                       |
       |                       |
       -------------------------

calculate the scale factor you would need to make S1 and S2 fall together (simply the ratio of the sum of M1-S1 and S2-M2 to M1-M2), and

finally scale the circle by the maximum of the found scale factors.

Edit: This is the exact solution. However, a little thought can optimize this further for speed:

You only need to do this for the squares closest to 45° (if n is even) resp. 45° and 135° (if n is odd; actually, you might prove that only one of these is necessary).
For large n, the optimal spacing of the squares on the circle will quickly approach the length of a diagonal of a square. You could thus precompute the scaling factors for a few small n (up to a dozen or so), and then have a good enough approximation with the diagonal.