Python 如何在numpy中创建一个不断增加的多维数组

我试图在给定单应矩阵的情况下执行反向扭曲，为了有效地执行此操作，我需要一个如下所示的numpy数组：

([[0, 0, 1], [0, 1, 1], [0, 2, 1], ... [1, 0, 1], [1, 1, 1], ... [n, p, 1]])

其中n是图像的宽度（

im.shape[0]

），p是图像的高度（

im.shape[1]

）。有没有关于如何高效地构建这样的numpy阵列的想法

编辑：

有一些关于哪一种最快的讨论，如果有人有任何关于这一点的信息，我想听到会很有趣。我感谢大家的帮助

您可以使用创建栅格（每个子阵列的前两个条目）来连接它们：

>>> x, y = np.mgrid[:3, :3]   # assuming a 3x3 image
>>> np.stack([x.ravel(), y.ravel(), np.ones(x.size, dtype=int)], axis=1)
array([[0, 0, 1],
       [0, 1, 1],
       [0, 2, 1],
       [1, 0, 1],
       [1, 1, 1],
       [1, 2, 1],
       [2, 0, 1],
       [2, 1, 1],
       [2, 2, 1]])

在本例中，我使用3作为宽度和高度，但通过更改

np.mgrid

的参数，您可以更改它们。

在一行中：

np.vstack([np.indices(im.shape), np.ones((1, *im.shape))]).reshape(3,-1).T

---

基本上，获取此类索引的关键是使用

index

、

mgrid

/

meshgrid

等类似工具。

您可以使用

numpy.tile

和

numpy.repeat

和预先分配的容器来完成这一切，而无需循环

import numpy as np
arr = np.empty([n*p,3])
arr[:,0] = np.repeat(np.arange(n),p)
arr[:,1] = np.tile(np.arange(p),n)
arr[:,2] = 1

由@unutbu使用-

def indices_one_grid(n,p):
    ar = np.ones((n,p),dtype=int)
    return indices_merged_arr_generic_using_cp(ar)

样本运行-

In [141]: indices_one_grid(n=3,p=4)
Out[141]: 
array([[0, 0, 1],
       [0, 1, 1],
       [0, 2, 1],
       [0, 3, 1],
       [1, 0, 1],
       [1, 1, 1],
       [1, 2, 1],
       [1, 3, 1],
       [2, 0, 1],
       [2, 1, 1],
       [2, 2, 1],
       [2, 3, 1]])

标杆管理 其他办法-

def MSeifert(n,p):
    x, y = np.mgrid[:n, :p]
    return np.stack([x.ravel(), y.ravel(), np.ones(x.size, dtype=int)], axis=1)

def DanielF(n,p):
    return np.vstack([np.indices((n,p)), np.ones((1, n,p))]).reshape(3,-1).T

def Aaron(n,p):
    arr = np.empty([n*p,3])
    arr[:,0] = np.repeat(np.arange(n),p)
    arr[:,1] = np.tile(np.arange(p),n)
    arr[:,2] = 1
    return arr

时间安排-

In [152]: n=1000;p=1000

In [153]: %timeit MSeifert(n,p)
     ...: %timeit DanielF(n,p)
     ...: %timeit Aaron(n,p)
     ...: %timeit indices_one_grid(n,p)
     ...: 
100 loops, best of 3: 15.8 ms per loop
100 loops, best of 3: 8.46 ms per loop
100 loops, best of 3: 10.4 ms per loop
100 loops, best of 3: 4.78 ms per loop

---

我总是忘记2D是更简单、更快的方法。@MSeifert有时可能较慢的是np.stack产生的内存分配。。。如果索引比repeat和tile更快，那么可能是正确的。@Aaron这是相同的内存分配，只是顺序不同而已。我先创建小数组，然后使用堆栈创建大数组。当你先创建大的，然后再创建小的，然后复制到大数组中时，你不需要说“感谢你的帮助”—你。但是说明您对基准测试或最快的解决方案感兴趣是合适的。但也许你想要你的“编辑”。）很棒的基准测试。感谢您如此深入的回复！我想你有个打字错误*@johnktejik不，那是打开元组