Divide a two dimensional array into surfaces - php

Question

For a project it's required to arrange a two dimensional array into planes that are in proportion to each other based on a the percentage of each plane. (I hope this make sense, else see example below). In this 2D array the 'first' level represents the rows and the 'second' level, the columns. For example;
array(
// row 1
array(
// items
number1
number2
numberN
),
// row 2
array(
// items..
),
// row N
array(
// items..
)
)
The numbers in this array has te be added/arranged in such a way that they form panels. The panels together form one grid. Each digit is representing a item (doesn't matter for the question what this is). I came up with a solution myself. Click here for print of the 2D array (The groups are color coded.).
Lets say, there are three groups (listed below). The groups do represent the panels, introduced above. Each group has some percentage between zero and hundred. The sum of the percentage of the planes is required to be hundred percent. The maximum amount of group is seven. Example group info;
Group 1 (Panel A): 70%
Group 2 (Panel B): 20%
Group 3 (Panel C): 10%
Again this arrangement should result in one large panel with (sub)panels in it. As shown in this schematic figure.
I came up whit the idea to divide the end result into 4 corners. Each corner will be calculated by the rules. These corners should than be mirror (horizontally and/or vertically) based on what corner it is (Upper left, Upper right, Lower left, Lower right).
List of rules;
The number of items should be te same for each row
The aspects ratio of the complete grid should be 2 to 1. So the width is two times the hight.
The amount of rows are based on the total items, since the aspect is known.
After some days of work I was able to come up with a working script. But this does act weird (weird as in, not as expected) in some cases. See current solution above.
So, my question is; How do lever designers this? Is this a known problem and are there solution (like algorithm) what solve this (kind of) questions? I am struggling with the following problem for a long time now. Searching on the internet, trying to find similar problems. But I did not succeed.
I am not asking for a ready made solution. Just a pointer in the right direction would be much appreciated.

Answer 1

Assuming the planes should have approximately the same "aspect ratio" as the complete matrix, you could use this algorithm:
Calculate for each percentage what would be the coefficient to apply to the width and height to get the exact area that would be left over after subtracting the percentage of the available area. This coefficient is the square root of the coefficient that needs to be applied to the area (related to the percentage).
As this coefficient will in general be a non-integer number, check which way of rounding the width and height yields an area that comes closest to the desired area.
Repeat this for each plane.
Here is the code:
function createPlanes($width, $height, $groupPercentages) {
$side = 0;
$area = $width * $height;
$planeWidth = $width;
$planeHeight = $height;
$sumPct = 0;
$coefficient2 = 1;
foreach ($groupPercentages as $i => $pct) {
$plane = [
"column" => floor(($width - $planeWidth) / 2),
"row" => floor(($height - $planeHeight) / 2),
"width" => $planeWidth,
"height" => $planeHeight,
];
$coefficient2 -= $pct / 100;
$coefficient = sqrt($coefficient2);
$planeArea = $coefficient2 * $area;
$planeWidth = $coefficient * $width;
$planeHeight = $coefficient * $height;
// determine all possible combinations of rounding:
$deltas = [
abs(floor($planeWidth) * floor($planeHeight) - $planeArea),
abs(floor($planeWidth) * min(ceil($planeHeight), $plane["height"]) - $planeArea),
abs(min(ceil($planeWidth), $plane["width"]) * floor($planeHeight) - $planeArea),
abs(min(ceil($planeWidth), $plane["width"]) * min(ceil($planeHeight), $plane["height"]) - $planeArea)
];
// Choose the one that brings the area closest to the required area
$choice = array_search(min($deltas), $deltas);
$planeWidth = $choice & 2 ? ceil($planeWidth) : floor($planeWidth);
$planeHeight = $choice & 1 ? ceil($planeHeight) : floor($planeHeight);
$newSumPct = ($area - $planeWidth * $planeHeight) / $area * 100;
$plane["pct"] = $newSumPct - $sumPct;
$sumPct = $newSumPct;
$planes[] = $plane;
}
return $planes;
}
// Example call for a 2D array with 20 columns and 32 rows, and
// three percentages: 10%, 20%, 70%:
$planes = createPlanes(20, 32, [10, 20, 70]);
The $planes variable will get this content:
array (
array (
'column' => 0,
'row' => 0,
'width' => 20,
'height' => 32,
'pct' => 10.9375,
),
array (
'column' => 0,
'row' => 1,
'width' => 19,
'height' => 30,
'pct' => 20,
),
array (
'column' => 1,
'row' => 3,
'width' => 17,
'height' => 26,
'pct' => 69.0625,
),
)
The inner attributes define where the plane starts (row, column), and how large it is (height, width), and which is the actual percentage that plane is in relation to the total area.
Note that the actual 2D does not need to be part of the algorithm, as its values don't influence it.