Question

我有一个嘈杂的X，Y点的未排序列表。然而，他们确实形成了通往世界的道路。我想要一种算法来使用线段绘制这些数据的近似值。

这类似于使用线性拟合算法来选择近似线性数据的方法。我的问题只会更难，因为这条路在世界各地弯曲和蜿蜒。 alt text http://www.praeclarum.org/so/pathfinder.png

有没有人知道任何标准/强大/易于理解的算法来实现这一目标？

问＆安培; A ：

嘈杂是什么意思？如果我有一个理想的路径实现，那么我的一组点将从理想路径中采样，并将高斯噪声添加到X和Y元素。我不知道那个噪音的均值或标准差。我或许可以猜到std dev ......

这些点是否靠近，但不是在你想要近似的一些理想但复杂的路径上？是的。

你有关于他的路径形状的先验信息吗？获取此类信息的任何其他方式？不幸的是没有。

Answer 1

Bezier Interpolation可能适合您的问题。

Bezier Interpolation

然而，这并没有解决点到路径的顺序;有许多方法需要考虑：

任何“最佳”路径类型（例如路径上每个点的最小方向变化，*通过所有点的最短路径）都可能会使NP完全Travelling Salesman Problem（TSP）归结。
聚合节点然后在群集之间以及群集内路由的“合理”路径。当然，群集越大，或者群集的数量越大，这个小问题看起来就像一个大的n TSP。
按一个轴排序点。如果有超过2个轴，则某些dimensional reduction策略可能有用。例如独立成分分析。

Answer 2

使用未排序的列表，你不会真正知道每个段中包含哪些点，所以我猜你可以选择最接近的点。

一种方法是随机选择一个起始点，并选择最近的点作为每个步骤中的下一个点。将前两个点添加到集合S。

在S中的点拟合直到RMS超过某个值，然后清除S并开始换行。

连续线的交点将是段的终点。

Answer 3

如果您的点彼此接近，则可以是正常的“直线”（正交线）。使用正常smoothing algorithms。你可以看到这个世界是扁平的。

如果它们相距很远，则需要使用great circles从一点到另一点进行导航来补偿地球的四舍五入。否则你的直线会走得更远。

如果一个点太远而无法创建直线，则可以选择。

此外，你必须知道你是否需要“访问”每个点，或者只是需要靠近，以及附近的距离。

如果您需要将课程发送到飞机，船舶或其他旅行者，您可能需要访问每个点。如果您从对象获取GPS数据，您可能只想在屏幕上绘制一个路线，并消除噪音。

看到您的修改后 如果这是一个移动您想要绘制的轨迹的对象，您可能希望平滑方向和速度而不是x / y值。（使您的测量值（x）具有固定且增加的Y间隔使得平滑变得更容易。）

Answer 4

这是一个启发式黑客，可以解决数据的排序问题，如果

你有足够的分数
与路径预期的最小曲率半径相比，点之间的平均距离较小
与std相比，点之间的平均距离不大。开发。噪音
路径不是自我穿越（你可能会幸运，但不能保证）

继续这样：

选择（希望通过有意义而非随机的方式）起点 p1 。
找到位于某个聚类距离内的所有点， r_c p1 。与预期的转弯半径相比，选择 r_c 较小，但与分散相比较大。
将此群集称为 C1 。
在 C1 中找到 q1 位置的平均值。
在 C1 中的点处插入一条线并投影到群集边缘（或刚刚超出），并找到原始数据中的最近点。标记点 p2 。
迭代步骤2-5直到您的数据用完为止。

现在您有一个新的点列表 q1 .. qn 。

脱离我的头顶，非常粗糙，只能在相当好的条件下工作......

通过在步骤（5）中要求新的投影线位于前一个投影线的某个最大角度内，可以改善自交行为。

Answer 5

Bezier曲线的问题在于，实际上并没有通过您采样的点，即使点样本有点失真; bezier曲线可能实际上是数英里之外。

更好的近似，并且似乎更好地类似于原始图像方式的解决方案是Catmull-Rom Spline，因为它确实运行了曲线中的所有点。

Answer 6

我的方法是首先对点列表进行排序，然后使用贝塞尔曲线。

诀窍当然是排序。从一个随机点开始，找到最近的点。假设这两个是相连的。使用这两个端点，找到最近的点。假设与其端点距离较小的那个连接到该点。重复，直到所有点都连接起来。

我认为这种方法仍然存在一些问题，但也许你可以将它作为一个起点（双关语）。

编辑：您可以使用不同的起点进行多次，然后查看结果的不同之处。这至少会给你一些信心，哪些点相互联系。

Answer 7

完全不同的方法，不需要其他约束，但细节可能取决于您的应用程序。如果路径周围有“密集的云点”，它会发挥得最好。

使用“成本”函数定义曲线和点云之间的差异。使用参数化曲线和标准优化算法。 - 要么 - 从头到尾以直线曲线开始，然后使用遗传算法对其进行修改。

典型的成本函数是采用每个点和曲线之间的最小距离，并对平方进行求和。

我没有足够的经验建议优化或遗传算法，但我相信它可以做到：）

我可以想象一个遗传算法如下：路径将从Waypoints构建。首先从开始到结束将N个航点放在一条直线上。（可根据问题选择N）。突变可能是：

对于每个段，如果rnd（）＆lt; x，中间引入了新的航点。
对于每个航点，X和Y坐标略有不同。

您需要在费用函数中包含总长度。可能不需要拆分，或者可能需要减少x（“分裂机会”），因为引入了更多的航路点。您可能想要也可能不想将（2）应用于起点和终点。

尝试这个会很有趣......

Answer 8

我认为“未分类列表”意味着当你的点数完成时，你不知道他们通过了什么顺序？

必须基本忽略高斯噪声。我们绝对没有任何信息可以让我们尝试重建原始的，不嘈杂的路径。所以我认为我们能做的最好就是假设这些点是正确的。

此时，任务包括“找到通过一组点的最佳路径”，“最佳”留下模糊。我掀起了一些试图在欧几里得空间中订购一组点的代码，更喜欢导致线条更直的订单。虽然该指标很容易实现，但我想不出一个改进基于此的排序的好方法，所以我只是随机交换点以寻找更好的安排。

所以，这里有一些PLT Scheme代码可以做到这一点。

#lang scheme

(require (only-in srfi/1 iota))

; a bunch of trig
(define (deg->rad d)
  (* pi (/ d 180)))

(define (rad->deg r)
  (* 180 (/ r pi)))

(define (euclidean-length v)
  (sqrt (apply + (map (lambda (x) (expt x 2)) v))))

(define (dot a b)
  (apply + (map * a b)))

(define (angle-ratio a b)
  (/ (dot a b)
     (* (euclidean-length a) (euclidean-length b))))

; given a list of 3 points, calculate the likelihood of the
; angle they represent. straight is better.
(define (probability-triple a b c)
  (let ([av (map - a b)]
        [bv (map - c b)])
    (cos (/ (- pi (abs (acos (angle-ratio av bv)))) 2))))

; makes a random 2d point. uncomment the bit for a 3d point
(define (random-point . x)
  (list (/ (random 1000) 100)
        (/ (random 1000) 100)
        #;(/ (random 1000) 100)))

; calculate the likelihood of an entire list of points
(define (point-order-likelihood lst)
  (if (null? (cdddr lst))
      1
      (* (probability-triple (car lst)
                             (cadr lst)
                             (caddr lst))
         (point-order-likelihood (cdr lst)))))

; just print a list of points
(define (print-points lst)
  (for ([p (in-list lst)])
    (printf "~a~n"
            (string-join (map number->string
                              (map exact->inexact p))
                         " "))))

; attempts to improve upon a list
(define (find-better-arrangement start
                                 ; by default, try only 10 times to find something better
                                 [tries 10]
                                 ; if we find an arrangement that is as good as one where
                                 ; every segment bends by 22.5 degrees (which would be
                                 ; reasonably gentle) then call it good enough. higher
                                 ; cut offs are more demanding.
                                 [cut-off (expt (cos (/ pi 8))
                                                (- (length start) 2))])
  (let ([vec (list->vector start)]
        ; evaluate what we've started with
        [eval (point-order-likelihood start)])
    (let/ec done
      ; if the current list exceeds the cut off, we're done
      (when (> eval cut-off)
        (done start))
      ; otherwise, try no more than 'tries' times...
      (for ([x (in-range tries)])
        ; pick two random points in the list
        (let ([ai (random (vector-length vec))]
              [bi (random (vector-length vec))])
          ; if they're the same...
          (when (= ai bi)
            ; increment the second by 1, wrapping around the list if necessary
            (set! bi (modulo (add1 bi) (vector-length vec))))
          ; take the values from the two positions...
          (let ([a  (vector-ref vec ai)]
                [b  (vector-ref vec bi)])
            ; swap them
            (vector-set! vec bi a)
            (vector-set! vec ai b)
            ; make a list out of the vector
            (let ([new (vector->list vec)])
              ; if it evaluates to better
              (when (> (point-order-likelihood new) eval)
                ; start over with it
                (done (find-better-arrangement new tries cut-off)))))))
      ; we fell out the bottom of the search. just give back what we started with
      start)))

; evaluate, display, and improve a list of points, five times
(define points (map random-point (iota 10)))
(define tmp points)
(printf "~a~n" (point-order-likelihood tmp))
(print-points tmp)
(set! tmp (find-better-arrangement tmp 10))
(printf "~a~n" (point-order-likelihood tmp))
(print-points tmp)
(set! tmp (find-better-arrangement tmp 100))
(printf "~a~n" (point-order-likelihood tmp))
(print-points tmp)
(set! tmp (find-better-arrangement tmp 1000))
(printf "~a~n" (point-order-likelihood tmp))
(print-points tmp)
(set! tmp (find-better-arrangement tmp 10000))
(printf "~a~n" (point-order-likelihood tmp))
(print-points tmp)

Answer 9

似乎你从问题的答案中知道了“黄金曲线”，我建议找到@jamesh建议的“黄金曲线”的Bezier曲线并绘制它。

Answer 10

你有多少分？
如上所述，Bezier曲线是一个好主意，如果你有相对较少的几点。如果你有很多分数，请按照dmckee的建议建立群集。

但是还需要另一个约束来定义点的顺序。关于如何选择点有很多很好的建议，但除非你引入另一个约束，否则任何一个都会给出一个可能的解决方案。

我能想到的可能的限制：

最短路径
大多数直段
最少总绝对旋转
方向偏好（即水平/垂直比十字交叉更可能）

在所有情况下，为了满足约束，您可能需要测试序列的所有排列。如果你从一个“好的猜测”开始，你可以快速终止其他人。

如何从嘈杂的X，Y数据中确定路径

10 个答案: