从左上到右下排序坐标

Question

我该如何尝试从左上角到右下角对不规则数组的点进行排序，如下图所示？

我考虑过的方法是：

• 计算每个点到图像左上角的距离（毕达哥拉斯定理），但对Y 坐标应用某种加权，以尝试优先考虑相同“row”上的点，例如distance = SQRT((x * x) + (weighting * (y * y)))

• 将点排序为逻辑行，然后对每一行进行排序。

部分困难在于我不知道图像中会出现多少行和列以及点阵列的不规则性。任何建议将不胜感激。

Answer 1

尽管这个问题有点老了，但我最近在校准相机时遇到了类似的问题。

算法相当简单，基于this paper:

• 找到左上角：min(x+y)
• 找到右上角：max(x-y)
• 从这些点创建一条直线。
• 计算所有点到直线的距离
  • 如果小于圆的半径（或阈值）：点在顶线上。
  • 否则：点在块的其余部分。
• 按 x 值对顶行的点进行排序并保存。
• 重复直到没有剩余点。

我的 python 实现如下所示：

#detect the keypoints
detector = cv2.SimpleBlobDetector_create(params)
keypoints = detector.detect(img)
img_with_keypoints = cv2.drawKeypoints(img, keypoints, np.array([]), (0, 0, 255), 
cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

points = []
keypoints_to_search = keypoints[:]
while len(keypoints_to_search) > 0:
    a = sorted(keypoints_to_search, key=lambda p: (p.pt[0]) + (p.pt[1]))[0]  # find upper left point
    b = sorted(keypoints_to_search, key=lambda p: (p.pt[0]) - (p.pt[1]))[-1]  # find upper right point

    cv2.line(img_with_keypoints, (int(a.pt[0]), int(a.pt[1])), (int(b.pt[0]), int(b.pt[1])), (255, 0, 0), 1)

    # convert opencv keypoint to numpy 3d point
    a = np.array([a.pt[0], a.pt[1], 0])
    b = np.array([b.pt[0], b.pt[1], 0])

    row_points = []
    remaining_points = []
    for k in keypoints_to_search:
        p = np.array([k.pt[0], k.pt[1], 0])
        d = k.size  # diameter of the keypoint (might be a theshold)
        dist = np.linalg.norm(np.cross(np.subtract(p, a), np.subtract(b, a))) / np.linalg.norm(b)   # distance between keypoint and line a->b
        if d/2 > dist:
            row_points.append(k)
        else:
            remaining_points.append(k)

    points.extend(sorted(row_points, key=lambda h: h.pt[0]))
    keypoints_to_search = remaining_points

Answer 2

跳到这个旧线程上，因为我刚刚处理了同样的事情：按从左到右、从上到下的位置对放置对象的草率对齐网格进行排序。原始帖子顶部的绘图完美地总结了它，除了此解决方案支持具有不同数量节点的行。

S。上面 Vogt 的脚本非常有用（下面的脚本完全基于他/她的脚本），但我的条件更窄。 Vogt 的解决方案包含一个可能从水平轴倾斜的网格。我假设没有倾斜，所以我不需要比较与可能倾斜的顶线的距离，而是与单个点的 y 值进行比较。

以下Javascript：

interface Node {x: number; y: number; width:number; height:number;}
const sortedNodes = (nodeArray:Node[]) => {
    let sortedNodes:Node[] = []; // this is the return value
    let availableNodes = [...nodeArray]; // make copy of input array
    while(availableNodes.length > 0){
        // find y value of topmost node in availableNodes. (Change this to a reduce if you want.)
        let minY = Number.MAX_SAFE_INTEGER;
        for (const node of availableNodes){
            minY = Math.min(minY, node.y)
        }
        // find nodes in top row: assume a node is in the top row when its distance from minY 
        // is less than its height
        const topRow:Node[] = [];
        const otherRows:Node[] = [];
        for (const node of availableNodes){
            if (Math.abs(minY - node.y) <= node.height){
                topRow.push(node);
            } else {
                otherRows.push(node);
            }
        }
        topRow.sort((a,b) => a.x - b.x); // we have the top row: sort it by x
        sortedNodes = [...sortedNodes,...topRow] // append nodes in row to sorted nodes
        availableNodes = [...otherRows] // update available nodes to exclude handled rows
    }
    return sortedNodes;
};

以上假设所有节点高度都相同。如果您有一些节点比其他节点高得多，则获取所有节点的最小节点高度值并使用它而不是迭代的“node.height”值。即，您可以更改上面脚本的这一行以使用所有节点的最小高度，而不是迭代的。

if (Math.abs(minY - node.y) <= node.height)

Answer 3

我提出以下想法：
1. 计算点数 (p)
2. 对于每个点，将其 x 和 y 坐标四舍五入到某个数字，例如
x = int(x/n)*n, y = int(y/m)*m 对于某些 n,m 3. 如果 m,n 太大，计数会下降。迭代地确定 m, n 以便保留点数p。

起始值可能与max(x) - min(x) 一致。对于搜索，请使用二进制搜索。 X 和 Y 缩放将彼此独立。

用自然的话来说，这将通过拉伸或缩小网格距离将各个点固定到网格点，直到所有点最多具有一个公共坐标（X 或 Y）但没有 2 个点重叠。你也可以称之为分类。