Question

I am working on a project where I need to create a boundary around a group of rectangles.

Let’s use this picture as an example of what I want to accomplish.

EDIT: Couldn’t get the image tag to work properly, so here is the full link: http://www.flickr.com/photos/21093416@N04/3029621742/

We have rectangles A and C who are linked by a special link rectangle B. You could think of this as two nodes in a graph (A,C) and the edge between them (B). That means the rectangles have pointers to each other in the following manner: A->B, A<-B->C, C->B

Each rectangle has four vertices stored in an array where index 0 is bottom left, and index 3 is bottom right.

I want to ‘traverse’ this linked structure and calculate the vertices making up the boundary (red line) around it. I already have some small ideas around how to accomplish this, but want to know if some of you more mathematically inclined have some neat tricks up your sleeves.

The reason I post this here is just that someone might have solved a similar problem before, and have some ideas I could use. I don’t expect anyone to sit down and think this through long and hard. I’m going to work on a solution in parallell as I wait for answers.

Any input is greatly appreciated.

Answer 1

Using the example, where rectangles are perpendicular to each other and can therefore be presented by four values (two x coordinates and two y coordinates):

   1   2   3   4   5   6  1  +---+---+    |       |    2  +   A   +---+---+    |       | B     | 3  +       +   +---+---+    |       |   |   |   | 4  +---+---+---+---+   +                |       | 5              +   C   +                |       | 6              +---+---+ 

1) collect all the x coordinates (both left and right) into a list, then sort it and remove duplicates

1 3 4 5 6

2) collect all the y coordinates (both top and bottom) into a list, then sort it and remove duplicates

1 2 3 4 6

3) create a 2D array by number of gaps between the unique x coordinates * number of gaps between the unique y coordinates. It only needs to be one bit per cell, so in c++ a vector<bool> with likely give you a very memory-efficient version of this

4 * 4

4) paint all the rectangles into this grid

    1   3   4   5   6  1  +---+    | 1 | 0   0   0 2  +---+---+---+    | 1 | 1 | 1 | 0 3  +---+---+---+---+    | 1 | 1 | 1 | 1 | 4  +---+---+---+---+      0   0 | 1 | 1 | 6          +---+---+ 

5) for each cell in the grid, for each edge, if the cell beside it in that cardinal direction is not painted, draw the boundary line for that edge

---

In the question, the rectangles are described as being four vectors where each represents a corner. If each rectangle can be at arbitrary and different rotation from others, then the approach I’ve outlined above won’t work. The problem of finding the path around a complex polygon is regularly solved by vector graphics rasterizers, and a good approach to solving the problem is using a library such as Cairo to do the work for you!