Sub-dividing a polygon into smaller polygons [closed]

In OpenStreetMap data, some large areas are tagged with a residential=yes tag. Actually within this large polygon there are multiple smaller (rectangular) houses (which are actually not drawn as yet). I would like to 'slice' the large polygon into smaller rectangular polygons. Or looking at it another way, I would like to or auto-generate as many fixed size rectangles (houses) into the larger area. I would like to achieve this either using QGIS or MapWindow, as I do not have ArcGIS. Is there any way to do this?

• Please decide whether it is QGIS or MapWindow that you wish to ask about in this particular question.
– PolyGeo
Commented May 3, 2023 at 20:10

It won't look terribly realistic without taking into account roads. I suggest you'll need to work out a few classes of population density / urbanization, and build separate models for how you'd populate each one. A very simplistic low-population suburban model may look like:

• Split road lines into the segments that exist between intersection nodes
• Calculate length of road segments
• Divide road segment lengths by 100m and modulo by 1 to get N
• Divide road segment lengths by N to get H
• Every H meters along a road segment, create a 201m-long line centered on the road, perpendicular to the road
• Buffer all roads by 100m
• Split those buffers by the perpendicular line layer to create initial lots
• Split those initial lots by the road segment layer to make a final lots layer
• Establish centroids for those final lots
• Paste a house model in a random orientation (or pointed towards the nearest road if you can figure out how) at each final lot

This should give you, very roughly, something like this, albeit without the cul-de-sac effect:

Roads will be important, so take your centerline roads geometry file, buffer it by 13' to get 26' wide streets. Use the roads-buffer polygon to clip the neighborhood polygon. Take the resulting polygon, negative buffer it by 10-20' to represent building setback, call it 'builable_lots". Second negative buffer, 50' deep, call it 'back_yards'.

Then overlay a grid of points at a scale of about 'yard size', say 30-50' offset, and use buildable_lots and back_yards polygon to select points that could be houses. Buffer each point by half a house width (15'). Then use the buildable_lots and backyards to clip off the front/back of each circle, so you've got little polygons composed to two arcs and two flat-ish sides, each representing a house. Then put a square minimum bound geography envelope around each house-ish thing.

Use an iterative negative buffer, sort of like a Serpinksy square, by repeatedly splitting the polygon into sub-polygons and negatively buffering them. Buffer distance (-20) to get an inset polygon, split that polygon into quarters. Repeat the negative buffer on that polygon. Do that until the size of the resulting polygon is roughly house-sized.