用于图像处理的Nx3列数据到二维矩阵

Question

我试图以Nx3数据的格式(“x”、“y”、“value”)从文本文件中找到局部最大值和可数线；'x‘和'y’形成一个间隔均匀的网格，并且对于'x‘、'y’的每一个组合都有一个值，如下所示：

  3.0, -0.4, 56.94369888305664        
  3.0, -0.3, 56.97200012207031        
  3.0, -0.2, 56.77149963378906        
  3.0, -0.1, 56.41230010986328        
  3.0,  0,   55.8302001953125       
  3.0,  0.1, 55.81560134887695        
  3.0,  0.2, 55.600399017333984        
  3.0,  0.3, 55.51969909667969        
  3.0,  0.4, 55.18550109863281         
  3.2, -0.4, 56.26380157470703 
  3.2, -0.3, 56.228599548339844
  ...

问题是，我试图使用的图像代码(链接)要求数据以不同的2d矩阵格式进行图像处理。这是守则的有关部分：

# Construct some test data
x, y = np.ogrid[-np.pi:np.pi:100j, -np.pi:np.pi:100j]
r = np.sin(np.exp((np.sin(x)**3 + np.cos(y)**2)))

# Find contours at a constant value of 0.8
contours = measure.find_contours(r, 0.8)

有人能帮我把我的数据转换成所需的“网格”格式吗？

编辑：，我最终选择了熊猫，但我发现在一般的case.This中选择的答案更好，这就是我所做的：

from pandas import read_csv
data=read_csv(filename, names=['x','y','values']).pivot(index='x', columns='y',
              values='values')

在此之后，data.values就像我想要的那样，以2d的“图像形式”保存表。

y   -0.4        -0.3        -0.2        -0.1
x               
3.0  86.9423     87.6398     87.5256     89.5779
3.2  76.9414     77.7743     78.8633     76.8955
3.4  71.4146     72.8257     71.7210     71.5232

Answer 1

最好的解决办法确实取决于你不给予的细节。顺便说一句，您应该使用给出您的代码，或者至少给出np.loadtxt指令。在以下内容中，"data“是使用以下方法从文件中加载的数组：

data = np.loadtxt('file.txt', [('x',float), ('y',float), ('value',float)])

1)直接重塑：

跟着@tom10说的话

如果您知道您的(x，y，value)数据按特定顺序存储：

[(x0,y0,v00), (x0,y1,v01), .... , (x1,y0,v10),(x1,y1,v11), ... ,(xN,yM,vNM)]

并给出了所有(x，y)对的值。那么最好的方法是从您的值列表中创建一个一维numpy数组，并对其进行整形：

x = np.unique(data['x'])
y = np.unique(data['y'])
r = data['value'].reshape((x.size,y.size))

2)一般案件：

有关类似问题和使用字典的其他解决方案，请参见https://stackoverflow.com/questions/6150375/populate-arrays-in-python-numpy。

如果您不能保证除了(x，y，value)元组以外的其他任何东西：

# indexing: list of x and y coordinates, and functions that map them to index
x  = np.unique(data['x']).tolist()
y  = np.unique(data['y']).tolist()
ix = np.vectorize(lambda i: x.index(i), otypes='i')
iy = np.vectorize(lambda j: y.index(j), otypes='i')

# create output array
r  = np.zeros((x.size,y.size), float)   # default value is 0
r[ix(data['x']), iy(data['y'])] = data['value']

注:在上面给出的参考文献中，给出了另一种使用字典的方法。我认为这是更易读的，但我没有测试他们的相对速度。

( 3)中级案件？

您可能有一个中间情况，在以特定顺序给定的常规网格坐标之间，而根本没有约束。在一般情况下，可能非常慢，您应该设计您的算法，以利用您的数据遵循的任何规则。

一个例子是，如果您知道x索引遵循特定的规则，但不一定是按顺序进行的。例如，如果您知道x和y是等距的“网格”坐标，则表单：

coordinate = min_coordinate + i*step

然后找到min_coordinate和step (对于x和y)，并通过求解这个方程找到i。这样，就可以避免代价高昂的索引映射np.vectorized(.List.index(.))

x  = np.unique(data['x'])
y  = np.unique(data['y'])
ix = (data['x']-x.min())/(x[1]-x[0])
iy = (data['y']-y.min())/(y[1]-y[0])

# create output array
r  = np.ones((x.size,y.size), float)*np.nan   # default value is NaN
r[ix.astype(int), iy.astype(int)] = data['value']