删除一行中的多余点

Question

我正在研究一种算法，该算法在简单的黑白地图中分析大陆的形状，并返回其周长的 ouline。

一个例子如下：[(1,0), (2,0), (2,1), (2,2), (3,2)...]

到目前为止，该算法生成了正确的列表，但正如您所见，它生成了冗余点。

在示例中，第一个点之后的 3 个点形成一条直线，从 2,0 到 2,2。 (2,1)，冗余点，应该被消除，但我不确定如何。

仅供参考：我在一个纯 python 应用程序中工作，我使用的唯一库是 pygame。 我在没有运气的情况下研究过类似的问题。

Answer 1

3 个点 (x ₁ ,y ₁ )、(x ₂ ,y ₂ ) 和 (x ₃ ,y ₃ ) 共线（在一条线上），如果：

(x ₂ -x ₁ )(y ₃ -y ₂ ) - (y ₂ -y ₁ )(x ₃ -x ₂ ) = 0

每当轮廓中连续 3 个点共线时，中间的点是多余的，可以删除。

您可以在向列表中添加点时逐步执行此操作。 如果列表中至少有 2 个点，则在添加另一个点之前，检查它是否与最后 2 个共线。如果是，则在添加新点之前删除最后一个。

完成后，检查起点和终点以查看它们是否多余，如果是，则将其删除。

Answer 2

如果我正确理解您的帖子，如果前一个点和下一个点之间的距离与该点与其相邻点之间的距离之和相同，则该点是“冗余的”。

代码（未经测试）：

def diffVector(pointA, pointB):
  # returns a vector representing the path to get from A to B
  return (pointB[0] - pointA[0], pointB[1] - pointA[1])

def distSq(pointA, pointB):
  # returns the square of the distance between two points
  # (more efficient than actual distance, and works for our purposes)
  diff = diffVector(pointA, pointB)
  return diff[0] * diff[0] + diff[1] * diff[1]

def findRedundancy(points):
  # returns a list of redundant point indexes to remove
  redundant = []
  # store the distance in a variable to avoid recalculating
  prevSegmentDist = distSq(points[0], points[1])
  for i, point in enumerate(points[1:-2]):
    prev = points[i-1]
    next = points[i+1]
    nextSegmentDist = distSq(point, next)
    # check if the combined distance is the same
    # as the straight-line distance between prev and next
    if distSq(prev, next) == prevSegmentDist + nextSegmentDist:
      redundant.append(i)
    prevSegmentDist = nextSegmentDist
  return redundant

该算法容易出现浮点错误，因此您应该替换严格的==检查，以支持检查数字彼此足够接近以被视为“相同”。

Answer 3

假设点是有序的，如果下一个点直接在前一个点后面，你基本上想丢弃一个点。

from math import isclose


def lined_up(bef, p, aft):
    if p[1] - bef[1] == 0:
        if aft[1] - p[1] == 0:
            # matching signs
            return p[0] - bef[0] < 0 == p[0] - bef[0] < 0
        else:
            return False
    elif aft[1] - p[1] == 0:
        return False
    else:
        return isclose(
            (p[0] - bef[0]) / (p[1] - bef[1]),
            (aft[0] - p[0]) / (aft[1] - p[1]),
            rel_tol=1e-8
        )


def remove_redundant_points(pts):
    # remove redundant end points overlapping with the starting point
    while len(pts) > 1 and pts[-1] == pts[0]:
        pts = pts[:-1]
    return [pts[0]] + [p for bef, p, aft in zip(pts[0:-2], pts[1:-1], pts[2:])
            if not lined_up(bef, p, aft)] + [pts[-1]]


points = [(1, 0), (3, 0), (2, 0), (2, 1), (2, 2), (3, 3), (6, 6), (0, 2), (1, 0)]
print(remove_redundant_points(points))

请注意使用math.isclose以避免浮点除法错误。

输出：

[(1, 0), (2, 0), (2, 2), (6, 6), (0, 2)]