什么算法可用于以相当优化的方式将不同大小的矩形打包成最小的矩形？

Question

我有一堆矩形物体，我需要将它们打包到尽可能小的空间中（这个空间的尺寸应该是 2 的幂）。

我知道各种打包算法可以尽可能地将物品打包到给定的空间中，但是在这种情况下，我需要算法来计算出该空间应该有多大。

例如说我有以下矩形

• 128*32
• 128*64
• 64*32
• 64*32

它们可以被打包成一个 128*128 的空间

_________________ |128*32 | |________________| |128*64 | | | | | |________________| |64*32 |64*32 | |________|________|

但是，如果还有 160*32 和 64*64 的，则需要 256*128 的空间

________________________________ |128*32 |64*64 |64*32 | |________________| |_______| |128*64 | |64*32 | | |_______|_______| | | | |________________|___ | |160*32 | | |____________________|_______|

有哪些算法能够打包一堆矩形并确定容器所需的大小（到 2 的幂，并且在每个维度的给定最大大小内）？

Answer 1

我相当肯定这是an NP-hard problem，因此，为了获得最佳解决方案，您必须实施回溯算法来尝试所有可能的组合。

好消息是，由于需要在有限的 2D 空间中打包 2D 矩形，因此您可以尽早修剪很多可能性，因此可能还不错。

Answer 2

看看packing problems。我认为您的属于“二维装箱”。您应该能够从该问题和其他包装问题的解决方案中学到很多东西。

另见：Packing rectangular image data into a square texture.

Answer 3

一个通用的解决方案是不平凡的（数学说明完全不可能）
通常人们使用遗传算法来尝试可能的组合，但您可以通过将最大的形状放在最前面，然后尝试不同的位置以获得下一个最大的形状，等等。

Answer 4

快速而肮脏的第一次通过解决方案总是一个很好的开始，作为比较，如果没有别的。

从大到小贪婪摆放。

将剩余的最大矩形放入打包区域。如果它不适合任何地方，请将其放置在尽可能少地扩展背包区域的地方。重复直到你完成最小的矩形。

它一点也不完美，但它很简单，而且是一个不错的基线。它仍然会完美地打包您的原始示例，并为您提供第二个相同的答案。

Answer 5

关于这个问题有大量文献。一个好的贪心启发式方法是将矩形从最大区域到最小区域放置在容器底部和左侧的第一个可用位置。想象一下重力将所有物品拉到左下角。有关此谷歌“Chazelle 左下包装”的描述。

为了获得最佳解决方案，最先进的技术可以在几秒钟内打包 20 多个矩形。 Huang 有一个algorithm，它将寻找最小包围框的问题与决定一组矩形是否可以放入特定大小的边界框的问题分开。你给他的程序一组矩形，它会告诉你打包它们所需的最小封闭边界框。

对于您的情况，您的外部循环应从可能的最小边界框向上迭代（宽度和高度依次增加 2 的幂）。对于这些边界框中的每一个，测试您是否可以找到适合您的矩形的包装。你会得到一堆“否”的答案，直到第一个“是”的答案，这将保证是最优解。

对于算法的内部循环——对特定大小的边界框回答“是”或“否”的循环，我会查找 Huang 的参考资料并实施他的算法。他在基本算法的基础上做了很多优化，但你真的只需要基本的肉和土豆。由于您要处理旋转，因此在搜索过程中的每个分支点，只需在两种旋转都没有解决方案时尝试旋转和回溯。

Answer 6

有关解决方案的调查，请参阅 this page on the ARC project，在实现复杂性/时间和最优性之间进行权衡，但有多种算法可供选择。

以下是算法的摘录：

1. 首次拟合递减高度 (FFDH) 算法
   FFDH 在 R 适合的第一层包装下一个项目 R（在非增加的高度）。如果没有级别可以容纳 R，则会创建一个新级别。
   FFDH的时间复杂度：O(n·log n)。
   近似比：FFDH(I)

2. 下一次拟合递减高度 (NFDH) 算法
   如果 R 适合，NFDH 会在当前级别上打包下一个项目 R（非增加高度）。否则，当前关卡将“关闭”并创建一个新关卡。
   时间复杂度：O(n·log n)。
   近似比：NFDH(I)

3. 最佳拟合递减高度 (BFDH) 算法
   BFDH 在能够容纳 R 的项目中，将水平上的下一个项目 R（非递增高度）打包，其中剩余水平空间最小。如果没有级别可以容纳 R，则创建一个新级别。

4. 左下 (BL) 算法
   BL 不增加宽度的第一个订单项目。 BL 将下一个项目尽可能靠近底部包装，然后尽可能靠近左侧而不与任何已包装的项目重叠。请注意，BL 不是面向级别的打包算法。
   时间复杂度：O(n^2)。
   近似比：BL(I)

5. 贝克的上下 (UD) 算法
   UD 结合了 BL 和 NFDH 的泛化。条带和项目的宽度被归一化，以便条带具有单位宽度。 UD 以非递增宽度对项目进行排序，然后将项目分为五组，每组宽度在 (1/2, 1], (1/3,1/2], (1/4,1/3) 范围内], (1/5,1/4], (0,1/5]。条带也分为五个区域R1,···,R5。基本上一些宽度在(1/i+ 1, 1/i], 对于 1 近似比：UD(I)

6. 反向拟合 (RF) 算法
   RF 还规范化条带和项目的宽度，使条带具有单位宽度。 RF首先堆叠所有宽度大于1/2的物品。其余物品按非递增高度排序，大于 1/2 的物品将在高度 H0 以上进行包装。然后RF重复以下过程。粗略地说，RF 从左到右包装物品，底部沿着高度 H0 线，直到没有更多空间。然后从右到左，从上到下（称为反向层）打包物品，直到总宽度至少为 1/2。然后反向水平下降，直到（至少）其中一个触及下面的某个项目。下拉菜单以某种方式重复。
   近似比：RF(I)

7. 斯坦伯格算法
   Steinberg 的算法，在论文中表示为 M，估计了打包所有项目所需的高度 H 的上限，从而证明输入项目可以打包成一个宽度为 W 和高度为 H 的矩形。然后他们定义了七个程序（有七个条件），每个程序将一个问题分成两个较小的问题并递归解决它们。已经证明，任何可处理的问题都满足七个条件之一。
   近似比：M(I)

8. Split-Fit 算法 (SF) SF将物品分为两组，L1宽度大于1/2，L2最多1/2。 L1的所有物品首先由FFDH包装。然后将它们排列成宽度大于 2/3 的所有项目都低于宽度最多 2/3 的项目。这将创建一个宽度为 1/3 的矩形空间 R。然后使用 FFDH 将 L2 中的剩余项目打包到 R 和与 L1 打包的项目上方的空间。在 R 中创建的级别被认为低于在 L1 的包装之上创建的级别。
   近似比：SF(I)

9. Sleator 算法
   Sleater 算法包括四个步骤：

   1. 宽度大于 1/2 的所有物品在条带底部相互叠放。假设 h0 是最终打包的高度，所有后续打包都将发生在 h0 以上。

   2. 剩余项目按非递增高度排序。沿着高度 h0 的线从左到右包装一个级别的项目（以非递增的高度顺序）。

   3. 然后在中间画一条垂直线，将条带切成相等的两半（注意这条线可能会切开部分包装在右半部分的物品）。绘制两条长度为一半的水平线段，一条穿过左半部（称为左基线），另一条穿过右半部（称为右基线），尽可能低，使两条线不与任何项目相交。

   4. 选择高度较低的左侧或右侧基线，将一层物品装入条带的相应一半，直到下一个物品太宽。

   形成一个新的基线，并在较低的基线上重复步骤 (4)，直到所有项目都被打包。
   时间复杂度：O(n·log n)。
   Sleator算法的逼近比是2.5，比较严格。

Answer 7

您需要的是 https://github.com/nothings/stb/blob/master/stb_rect_pack.h

样本：

stbrp_context context;

struct stbrp_rect rects[100];

for (int i=0; i< 100; i++)
{
    rects[i].id = i;
    rects[i].w = 100+i;
    rects[i].h = 100+i;
    rects[i].x = 0;
    rects[i].y = 0;
    rects[i].was_packed = 0;
}

int rectsLength = sizeof(rects)/sizeof(rects[0]);

int nodeCount = 4096*2;
struct stbrp_node nodes[nodeCount];


stbrp_init_target(&context, 4096, 4096, nodes, nodeCount);
stbrp_pack_rects(&context, rects, rectsLength);

for (int i=0; i< 100; i++)
{
    printf("rect %i (%hu,%hu) was_packed=%i\n", rects[i].id, rects[i].x, rects[i].y, rects[i].was_packed);
}