问题
我需要使用一组候选位置(X
和Y
中的值)构建2D网格。然而,可能存在应该被过滤掉的假阳性候选者,以及假阴性(其中需要针对给定周围位置值的预期位置创建位置)。可以预期网格的行和列是直的,旋转(如果有的话)。
此外,我没有关于(0,0)网格位置的可靠信息。不过我知道:
grid_size = (4, 4)
expected_distance = 105
(例外距离只是网格点之间间距的粗略估计,应允许在10%的范围内变化。)
示例数据
这是理想的数据,没有误报,也没有漏报。该算法需要能够处理删除多个数据点并添加错误的数据点。
X = np.array([61.43283582, 61.56626506, 62.5026738, 65.4028777, 167.03030303, 167.93965517, 170.82191781, 171.37974684, 272.02884615, 272.91089109, 274.1031746, 274.22891566, 378.81553398, 379.39534884, 380.68181818, 382.67164179])
Y = np.array([55.14427861, 160.30120482, 368.80213904, 263.12230216, 55.1030303, 263.64655172, 162.67123288, 371.36708861, 55.59615385, 264.64356436, 368.20634921, 158.37349398, 54.33980583, 160.55813953, 371.72727273, 266.68656716])
代码
以下函数评估候选者并返回两个词典。
第一个具有每个候选位置(作为2长度元组)作为键和值是位于右侧和下方位置的2长度元组(使用来自图像如何显示的逻辑)。这些邻居本身要么是2长的元组坐标,要么是None
。
第二个字典是第一个字典的反向查找,这样每个候选人(位置)都有一个支持它的其他候选人的位置列表。
import numpy as np
from collections import defaultdict
def get_neighbour_grid(X, Y, expect_dist=(105, 105)):
t1 = (expect_dist[0] + expect_dist[1]) / 2.0 * 0.9
t2 = t1 * 1.222
def neighbours(x, y):
nRight = None
ideal = x + expect_dist[0]
D = np.sqrt((X - ideal)**2 + (Y - y)**2)
candidate = (X[D.argmin()], Y[D.argmin()])
if candidate != (x, y) and x + t2 > candidate[0] > x + t1:
nRight = candidate
nBelow = None
ideal = y + expect_dist[0]
D = np.sqrt((X - x)**2 + (Y - ideal)**2)
candidate = (X[D.argmin()], Y[D.argmin()])
if candidate != (x, y) and y + t2 > candidate[1] > y + t1:
nBelow = candidate
return nRight, nBelow
right_below_neighbours = dict()
def _default_val(*args):
return list()
reverse_lookup = defaultdict(_default_val)
for pos in np.arange(X.size):
pos_tuple = (X[pos], Y[pos])
n = neighbours(*pos_tuple)
right_below_neighbours[pos_tuple] = n
reverse_lookup[n[0]].append(pos_tuple)
reverse_lookup[n[1]].append(pos_tuple)
return right_below_neighbours, reverse_lookup
这是我陷入困境的地方:
如何使用这些词典和/或X
和Y
构建支持最多的网格?
我有一个想法,从2个邻居支持的较低的,最右边的候选者开始,并使用reverse_lookup
字典迭代地创建网格。但是这种设计存在一些缺陷,最显而易见的是,我不能指望找到较低的,最右边的候选人及其支持的邻居。
这个代码,虽然它没有运行,因为当我意识到它有多么成问题时我放弃了它(pre_grid = right_below_neighbours
):
def build_grid(pre_grid, reverse_lookup, grid_shape=(4, 4)):
def _default_val(*args):
return 0
grid_pos_support = defaultdict(_default_val)
unsupported = 0
for l, b in pre_grid.values():
if l is not None:
grid_pos_support[l] += 1
else:
unsupported += 1
if b is not None:
grid_pos_support[b] += 1
else:
unsupported += 1
well_supported = list()
for pos in grid_pos_support:
if grid_pos_support[pos] >= 2:
well_supported.append(pos)
well_A = np.asarray(well_supported)
ur_pos = well_A[well_A.sum(axis=1).argmax()]
grid = np.zeros(grid_shape + (2,), dtype=np.float)
grid[-1,-1,:] = ur_pos
def _iter_build_grid(pos, ref_pos=None):
isX = pre_grid[tuple(pos)][0] == ref_pos
if ref_pos is not None:
oldCoord = map(lambda x: x[0], np.where(grid == ref_pos)[:-1])
myCoord = (oldCoord[0] - int(isX), oldCoord[1] - int(not isiX))
for p in reverse_lookup[tuple(pos)]:
_iter_build_grid(p, pos)
_iter_build_grid(ur_pos)
return grid
第一部分可能很有用,因为它总结了对每个职位的支持。它还显示了我需要的最终输出(grid
):
一个3D数组,其中第一个维度为网格形状,第三个维度为长度为2(对于每个位置的x坐标和y坐标)。
小结
所以我意识到我的尝试是如何无用的,但我不知道如何对所有候选人进行全局评估,并在任何适合的地方使用候选人的x和y值放置最受支持的网格。我希望这是一个非常复杂的问题,我真的不希望任何人给出一个完整的解决方案(尽管它会很棒),但任何类型的算法或numpy / scipy函数都可以使用的暗示非常感谢。
最后,抱歉这是一个有点冗长的问题。
修改
绘制我想要发生的事情:
星星/点是X
和Y
绘制的两个修改,我删除了第一个位置并添加了一个假的,以使其成为所搜索算法的完整示例。
我想要的是,换句话说,映射红圈位置的新坐标值(在它们旁边写的那些),以便我可以从新坐标(例如(1, 1) -> (170.82191781, 162.67123288)
)获得旧坐标。我还希望得到的点不是真实点所描述的理想网格被丢弃(如图所示),最后是使用理想网格参数“填充”的空理想网格位置(蓝色圆圈)(大约{{ 1}})。
解决方案
我使用提供的代码@skymandr获取理想参数,然后执行以下操作(不是最漂亮的代码,但它可以工作)。这意味着我不再使用(0, 0) -> (55, 55)
- 函数了。:
get_neighbour_grid
它提出了另一个问题:如何很好地沿2D阵列的对角线进行迭代,但我认为这值得问一个问题:More numpy way of iterating through the 'orthogonal' diagonals of a 2D array
修改
更新了解决方案代码,以便更好地处理更大的网格大小,以便它使用已经作为参考的相邻网格位置作为所有位置的理想坐标。仍然必须找到一种方法来实现从链接问题迭代网格的更好方法。
答案 0 :(得分:4)
这是一个相当简单和廉价的解决方案,但我不知道它有多强大。
首先,这是一种更好地估算间距的方法:
leeway = 1.10
XX = X.reshape((1, X.size))
dX = np.abs(XX - XX.T).reshape((1, X.size ** 2))
dxs = dX[np.where(np.logical_and(dX > expected_distance / leeway,
dX < expected_distance * leeway))]
dx = dxs.mean()
YY = Y.reshape((1, Y.size))
dY = np.abs(YY - YY.T).reshape((1, Y.size ** 2))
dys = dY[np.where(np.logical_and(dY > expected_distance / leeway,
dY < expected_distance * leeway))]
dy = dys.mean()
代码计算X和Y的内部差异,并取得所需间距的10%以内的平均值。
对于第二部分,找到网格的偏移量,可以使用类似的方法:
Ndx = np.array([np.arange(grid_size[0])]) * dx
x_offsets = XX - Ndx.T
x_offset = np.median(x_offsets)
Ndy = np.array([np.arange(grid_size[1])]) * dy
y_offsets = YY - Ndy.T
y_offset = np.median(y_offsets)
基本上,这样做的目的是让X
中的每个位置“投票”对于左下角可能位于NX = grid_size[0]
的位置,基于X - n * dx
n = 0
n = 1
是对点数本身的投票,dx
是对左边第一点{{1}}的投票等。这样,真正原点附近的点将获得最多的投票,并且偏移可以是发现使用中位数。
我认为这种方法在所需的原点周围足够对称,中位数可用于大多数(如果不是全部)情况。然而,如果存在许多误报,使得中位数由于某种原因不起作用,则可以使用例如“真实”来找到“真实”原点。直方图方法。