subdivide rectangle with specific rules - algorithm

Question

everybody.
first of all, i'm an amateur programmer. i'm trying to make a simple city-building application using C++ and SFML, for learning. it's not really a game, since it will just build the city blocks and buildings, and show them to the user.
for now, i'm able to create the city blocks. my problem is how to subdivide the blocks into buildings. i don't have a real idea on how to do it.
possible solutions would be (i don't have enough reputation to post images, but there's the link):
https://i.postimg.cc/630GKGW7/bitmap.png
the only rules are:
(1) each building must fit a minimum and maximum known size;
(2) each building must have at least one face touching any block edge;
(3) no empty spaces should remain.
i've been strugling with this for days. can anyone give me a idea on how to do it? pseudocode also would be great.
thanks in advance!

Answer 1

Just a note, I'll be using OOP syntax to make this easier, but it's not valid code. Let's first create an interface to define the behavior we want:
class CityBlock {
Building[] buildings // should initially contain one building taking up the whole CityBlock
double width
double height
double maxBuildingSize
double minBuildingSize
splitBuilding(horizontal/vertical, coord) // This will split a building horizontally/vertically
createRandomBuildings() // this is what we want to create!
}
class Building {
Point position // position of top-left corner
Building[] subBuildings // buildings created by subdivision
double width
double height
double size() { return width * height }
}
Now for the fun part! Let's try and make the createRandomBuildings() method. The approach I'll be taking is to repeatedly subdivide buildings until they are between 2 * minBuildingSize (less than that means no subdivide can create two valid buildings) and maxBuildingSize.
IMPORTANT NOTE: This approach only guarantees valid buildings if maxBuildingSize >= 2 * minBuildingSize, even if a valid subdivision is possible. Considering your use case, I figured the size constraint would not pose any issues, and a more "random" solution would be better as opposed to a more deterministic one.
Let's get to it! We'll create a recursive function called subdivide to do the heavy lifting.
Building[] subdivide(Building b, horizontal/vertical) {} // Subdivides b into a random number of other buildings
The way I'll subdivide each building is to split it into a random number of horizontal/vertical segments. Ex.
From this
To this
NOTE: To simplify matters, I'm going to work through this treating the subdivision as vertical, as in the image above. For a horizontal subdivision, just swap width/height.
Of course, we can't use any number of subdivisions. Too many, and all the resulting buildings will be too small. So we should first define the maximum number of subdivisions that will still allow us to create valid buildings.
minSubdivisionWidth = minSize / b.height // ensures that subdivisionWidth * b.height >= minSize
maxSubdivisions = floor(b.width / minSubdivisionWidth)
subdivisions = randomInt(2, maxSubdivisions)
Now that we have a valid number of subdivisions, we need to space them randomly while ensuring the buildings aren't too small. To do this, let's split the space we have available into two portions: minimum space and free space. Each subdivision will need to have the minimum space, but there is also free (or leftover) space equal to b.size() - minBuildingSize * subdivisions. This free space is what we want to randomly distribute among our subdivided rectangles.
Blue is minimum space, and pink is free space
Let's allocate this space:
widths[] // This will be the widths of our subdivided buildings
freeWidth = b.width - minSubdivisionWidth * subdivisions
weights[] // randomly assigned weight for free space
sumWeight
for i = 1 to subdivisions {
randWeight = random()
weights[i] = randWeight
sumWeight += randWeight
}
for i = 1 to subdivisions {
widths[i] = minSubdivisionWidth + (weights[i] / sumWeight) * freeWidth
}
And now we can do the actual subdivision:
// transform individual widths into coordinates for building split
cumulativeWidth = 0
for i = 1 to (subdivisions - 1) {
cumulativeWidth += widths[i]
splitBuilding(vertical, cumulativeWidth)
}
We're almost there! Now we just need a snippet to randomly not subdivide if the building is below the max:
probToNotSubdivide = .3 // obviously change this to whatever
if b.size() < maxBuildingSize and randomDouble(0, 1) <= probToNotSubdivide { return }
One to not subdivide if the building is too small:
if b.size() < minBuildingSize * 2 { return }
One to not subdivide if it would cut off a building from the edge of the block:
/*
If the building is touching a horizontal edge, vertical subdivisions
will not cut anything off. If the building is touching both
vertical edges, one subdivision can be made.
*/
if not (b.position.y == 0 or (b.position.y + b.height) == cityBlock.height) {
if b.width == cityBlock.width {
// do one subdivision and recurse
splitBuilding(vertical, randomDouble(minSubdivisionWidth, cityBlock.width - minSubdivisionWidth)
for subBuilding in b.subBuildings {
subdivide(horizontal, subBuilding)
}
return
} else { return }
}
Add a bit of recursion at the end and...
Building[] subdivide(Building b, horizontal/vertical) {
// exit conditions
if b.size() < maxBuildingSize and randomDouble(0, 1) <= probToNotSubdivide { return }
if b.size() < minBuildingSize * 2 { return }
/*
If the building is touching a horizontal edge, vertical subdivisions
will not cut anything off. If the building is touching both
vertical edges, one subdivision can be made.
*/
if not (b.position.y == 0 or (b.position.y + b.height) == cityBlock.height) {
if b.width == cityBlock.width {
// do one subdivision and recurse
splitBuilding(vertical, randomDouble(minSubdivisionWidth, cityBlock.width - minSubdivisionWidth)
for subBuilding in b.subBuildings {
subdivide(horizontal, subBuilding)
}
return
} else { return }
}
// get # subdivisions
minSubdivisionWidth = minSize / b.height // ensures that subdivisionWidth * b.height <= minSize
maxSubdivisions = floor(b.width / minSubdivisionWidth)
subdivisions = randomInt(2, maxSubdivisions)
// get subdivision widths
widths[] // This will be the widths of our subdivided buildings
freeWidth = b.width - minSubdivisionWidth * subdivisions
weights[] // randomly assigned weight for free space
sumWeight
for i = 1 to subdivisions {
randWeight = random()
weights[i] = randWeight
sumWeight += randWeight
}
for i = 1 to subdivisions {
widths[i] = minSubdivisionWidth + (weights[i] / sumWeight) * freeWidth
}
// transform individual widths into coordinates for building split
cumulativeWidth = 0
for i = 1 to (subdivisions - 1) {
cumulativeWidth += widths[i]
splitBuilding(vertical, cumulativeWidth)
}
// recurse
for subBuilding in b.subBuildings {
subdivide(horizontal, subBuilding)
}
}
And that's it! Now we have createRandomBuildings() { subdivide(vertical, initialBuilding) }, and we've subdivided our city block.
P.S. Again, this code isn't meant to be valid, and this is also a very long post. If something in here doesn't work right, edit/comment on this answer. I hope this gives some insight as to the approach you could take.
EDIT: To clarify, you should switch between horizontal and vertical subdivisions on each level of recursion.