Algorithm 正则空间细分

我正在写一个应用程序，它将一个N维轴对齐的边界框细分为更小的N维边界框，我需要一个算法来实现这一点。
例如：

在一维中，“边界框”只是一个长度
e、 g.{Min=0，Max=100}
可细分为
{Min=0，Max=50}和{Min=50，Max=100}

在二维中，“边界框”是正方形
e、 g.{Min=[0,0]，Max=[100100]}
将分为
{Min=[0,0]，Max=[50,50]}
{Min=[0,50]，Max=[50100]}
{Min=[50,0]，Max=[100,50]}
{Min=[50,50]，Max=[100100]}

等等，我所需要的只是一个算法的描述，语言并不特别重要，因为一旦我知道如何做，我就可以把它翻译成所选择的语言（在这种情况下是C）

编辑：：回答评论中的问题：

• 细分必须始终相等（如图所示） （在示例中）
• 边界是 浮点数，所以被2整除不是问题

---

将其分为两个问题：迭代“Min”点的网格，以及为Min点构造一个小框
对于第二种情况，{[0,0]，[100100]}，deltaX=50和deltaY=50。网格是
[0, 0] [0, 50] [50, 0] [50, 50] [0, 0] [0, 50] [50, 0] [50, 50] 从第一列构造第二列很简单：
[ 0, 0] [ 50, 50] [ 0, 50] [ 50, 100] [50, 0] [100, 50] [50, 50] [100, 100] [ 0, 0] [ 50, 50] [ 0, 50] [ 50, 100] [50, 0] [100, 50] [50, 50] [100, 100] 这是一个三维的例子{[0,0,0]，[100100,60]}，delta=[50,50,30]
[ 0, 0, 0] [ 50, 50, 30] [ 0, 0, 30] [ 50, 50, 60] [ 0, 50, 0] [ 50, 100, 30] [ 0, 50, 30] [ 50, 100, 60] [50, 0, 0] [100, 50, 30] [50, 0, 30] [100, 50, 60] [50, 50, 0] [100, 100, 30] [50, 50, 30] [100, 100, 60] [ 0, 0, 0] [ 50, 50, 30] [ 0, 0, 30] [ 50, 50, 60] [ 0, 50, 0] [ 50, 100, 30] [ 0, 50, 30] [ 50, 100, 60] [50, 0, 0] [100, 50, 30] [50, 0, 30] [100, 50, 60] [50, 50, 0] [100, 100, 30] [50, 50, 30] [100, 100, 60]

---

将其分为两个问题：迭代“Min”点的网格，以及为Min点构造一个小框
对于第二种情况，{[0,0]，[100100]}，deltaX=50和deltaY=50。网格是
[0, 0] [0, 50] [50, 0] [50, 50] [0, 0] [0, 50] [50, 0] [50, 50] 从第一列构造第二列很简单：
[ 0, 0] [ 50, 50] [ 0, 50] [ 50, 100] [50, 0] [100, 50] [50, 50] [100, 100] [ 0, 0] [ 50, 50] [ 0, 50] [ 50, 100] [50, 0] [100, 50] [50, 50] [100, 100] 这是一个三维的例子{[0,0,0]，[100100,60]}，delta=[50,50,30]
[ 0, 0, 0] [ 50, 50, 30] [ 0, 0, 30] [ 50, 50, 60] [ 0, 50, 0] [ 50, 100, 30] [ 0, 50, 30] [ 50, 100, 60] [50, 0, 0] [100, 50, 30] [50, 0, 30] [100, 50, 60] [50, 50, 0] [100, 100, 30] [50, 50, 30] [100, 100, 60] [ 0, 0, 0] [ 50, 50, 30] [ 0, 0, 30] [ 50, 50, 60] [ 0, 50, 0] [ 50, 100, 30] [ 0, 50, 30] [ 50, 100, 60] [50, 0, 0] [100, 50, 30] [50, 0, 30] [100, 50, 60] [50, 50, 0] [100, 100, 30] [50, 50, 30] [100, 100, 60]

---

在所有维度上分割长方体的函数（Python中）：
如果这是一个好的解决方案，还取决于您的性能要求。它制作了大量的阵列拷贝，这并不是真正有效的。但对于您的用例来说，它可能已经足够好了
编辑： 更高效的版本，不复制任何阵列：

def halfboxes(box):
   # total number of resulting arrays
   resultscount = 2**len(box)

   # allocate |resultscount| arrays
   results = [[] for i in range(resultscount)]

   spread = 1
   for (a,b) in box:
      low  = (a, (a+b)/2)
      high = ((a+b)/2, b)
      for i in range(resultscount):
         # "magic" to append the high/low parts to the correct array
         if i % (spread*2) < spread:
            results[i].append(low)
         else:
            results[i].append(high)
      spread *= 2
   return results

def半盒（盒）：
#结果数组的总数
结果计数=2**len（方框）
#分配|结果计数|数组
结果=[]对于范围内的i（结果计数）]
排列=1
对于方框中的（a，b）：
低=（a，（a+b）/2）
高=（（a+b）/2，b）
对于范围内的i（结果计数）：
#将高/低部分附加到正确数组的“magic”
如果i%（排列*2）<排列：
结果[i]。追加（低）
其他：
结果[i].追加（高）
价差*=2
返回结果

---

此处不复制任何数组，并使用索引上的一些计算来决定应在何处添加新边界。
在所有维度（Python中）拆分框的函数：
如果这是一个好的解决方案，还取决于您的性能要求。它制作了大量的阵列拷贝，这并不是真正有效的。但对于您的用例来说，它可能已经足够好了
编辑： 更高效的版本，不复制任何阵列：

def halfboxes(box):
   # total number of resulting arrays
   resultscount = 2**len(box)

   # allocate |resultscount| arrays
   results = [[] for i in range(resultscount)]

   spread = 1
   for (a,b) in box:
      low  = (a, (a+b)/2)
      high = ((a+b)/2, b)
      for i in range(resultscount):
         # "magic" to append the high/low parts to the correct array
         if i % (spread*2) < spread:
            results[i].append(low)
         else:
            results[i].append(high)
      spread *= 2
   return results

def半盒（盒）：
#结果数组的总数
结果计数=2**len（方框）
#分配|结果计数|数组
结果=[]对于范围内的i（结果计数）]
排列=1
对于方框中的（a，b）：
低=（a，（a+b）/2）
高=（（a+b）/2，b）
对于范围内的i（结果计数）：
#将高/低部分附加到正确数组的“magic”
如果i%（排列*2）<排列：
结果[i]。追加（低）
其他：
结果[i].追加（高）
价差*=2
返回结果

此处不复制任何数组，并使用索引上的一些计算来决定应在何处添加新边界。
• 计算第一个框：
尺寸n：最小值[0,0,0，…，0]——最大值[delta1/2，delta2/2，…，deltan/2]
• 您的大方框将被细分为2n个小方框->计算2n个要应用于第一个方框的转换（包括[0，0，0，…，0]的转换）
（当然，下面的代码没有经过优化组织…）

---

使用系统；
使用System.Collections.Generic；
命名空间Windows窗体应用程序1
{
公共班级1
{
公共静态列表getsmallbox（Box bigBox）
{
int translationCoef；
列表框=新列表（）；
盒子；
for（int k=0；k