Question

我正在尝试编写一个代码，该代码可以识别随机多义线（未闭合的一侧）的哪一侧是随机点。折线被认为是无限的，第一个和最后一个段延伸到无穷大。如果它们是交叉折线，则应将其视为多边形（我还没有详细说明此案例的代码）。逻辑如下：

1。定义折线的顶点，与所考虑的点之间的距离最小。变量minimum2p是到该顶点的距离，I2p是顶点的索引。

2. ：定义折线的线段，与所考虑的点之间的距离最小。只有那些段数（变量count_s）与所考虑的点的垂线相交。变量minimum2s是到段的最小距离; I2p是该段的第一个顶点的索引; flag是布尔变量，它存储与所提到的垂线相交的信息。

3。接下来只需选择适当的细分来与使用相比较，例如来自链接link-1，link-2或link-3的提示。我尝试了here的方法，但它对许多特殊情况都不起作用。我在那里使用the best answer作为折线的内部点。所以，我的方法如下：

4. 首先，检查它是否是折线的第一个或最后一个顶点。如果是这种情况，那么所选择的段相应地是第一个或最后一个，但仅当没有比第一个或最后一个更接近的其他段时。如果还有另一个细分，那么我选择了该细分。

5. 接下来，如果不是第4步，那么我会检查折线的内部顶点。如果附近还有一个段靠近，那么我会比较索引I2p和I2s（如果最后一个存在）。如果它们一致，那么选择适当的段进行比较就没有含糊之处。如果它们不同，则首选项将转到最近的段而不是最近的顶点。

6。最后，如果附近没有任何片段（从穿过片段的点垂直的意义上），那么对于内部顶点我应用the best answer {的想法{3}}

here用于不同的折线，由其顶点的X和Y坐标定义，相应地存储在'polylineX'和'polylineY'中（红色代表'left'位置，灰色代表“右”位置，黑色是折线上的位置，蓝色线代表折线。

正如您所注意到的，对于相对平滑的折线，代码可以正常工作。但是，对于更尖锐的，或者在某些方面复杂的，代码不能正常工作。我的代码中有什么错过的？考虑到某些情况应该添加什么条件？

代码如下：

clear all
close all 
clc
clf
polylineX = [0 1 2 3 4 5 6 7 8];
polylineY = [-10 20 -13 18 -17 16 -21 23 -25];
hold on
title(['polylineX=[',num2str(polylineX),'], polylineY=[',num2str(polylineY),']'])
chosen = 0;
span = 60;

for ii = 10:70
for jj = 30:60
    ii
    jj
    position = -2;
    point = [(jj-round(span/2))/1 (ii-round(span/2))/1];

    axis equal
    plot(polylineX,polylineY,'.-','MarkerSize',1,'LineWidth',1);

    distance2p = zeros(1,length(polylineX)); % distances from the point to the points (2p) of the polyline
    distance2s = zeros(1,length(polylineX)-1); % distances from the point to the segments (2s) of the polyline
    flag = zeros(1,length(polylineX)-1);
    count_s = 0; % counter of segments, which are intersected by the normal pointing from the 'point'
    k = 0;

    for i = 1:length(polylineX)-1
        pos = sign((polylineX(i+1) - polylineX(i)) * (point(2) - polylineY(i)) -...
                   (polylineY(i+1) - polylineY(i)) * (point(1) - polylineX(i)));

        % computing the distances from the 'point' to all segments and mark if
        % the distance vectors intersect the segments
        [flag(i),distance2s(i)] = distanceToLine([polylineX(i) polylineX(i+1)],[polylineY(i) polylineY(i+1)],[point(1) point(2)]);

        if flag(i)
            if k == 0
                minimum2s = distance2s(i);
                I2s = i;
            end;
            k = 1;
            count_s = count_s + 1; % count segments, which are intersected by the normal pointing from the 'point'
            if distance2s(i) < minimum2s
                I2s = i;
                minimum2s = distance2s(i);
            end;
        end;
    end;


    % first compute the distances between the 'point' under consideration and the
    % points of the given polyline
    for i  = 1:length(polylineX)
        distance2p(i) = sqrt((point(1)-polylineX(i))^2+(point(2)-polylineY(i))^2);
    end;
    [minimum2p,I2p] = min(distance2p);
    clear k pos i

    % now we need to choose which segment of the polyline to compare our 'point' with. These
    % segments are either adjacent to that point of the polyline, which is the closest
    % to the 'point' of interest, or the closest to the 'point' segment, which
    % has an intersection with the normale pointing from the 'point'.

    if I2p == 1 % if the 'point' is near the start of polyline
        if exist('minimum2s','var')
            if I2p == I2s
                chosen = I2p;
            else
                chosen = I2s;
            end;
        else
            chosen = I2p;
        end;

    elseif I2p == length(polylineX) % if the 'point' is near the end of polyline
        if exist('minimum2s','var')
            if I2s == I2p-1
                chosen = I2p - 1;
            else
                chosen = I2s;
            end;
        else
            chosen = I2p - 1;
        end;
    else
        if exist('minimum2s','var')
            if I2p == I2s
                chosen = I2p;

            else
                chosen = I2s;
            end;
        else
                pos1 =  sign((polylineX(I2p) - polylineX(I2p-1)) * (point(2) - polylineY(I2p-1)) -...
                 (polylineY(I2p) - polylineY(I2p-1)) * (point(1) - polylineX(I2p-1)));
                % position of the second segment relative to the first segment
                pos2 =  sign((polylineX(I2p) - polylineX(I2p-1)) * (polylineY(I2p+1) - polylineY(I2p-1)) -...
                             (polylineY(I2p) - polylineY(I2p-1)) * (polylineX(I2p+1) - polylineX(I2p-1)));
                if (pos1 == 1 && pos2 == 1) || (pos1 == -1 && pos2 == -1)
                    chosen = I2p;
                elseif pos1 == 0 || pos2 == 0
                    chosen = I2p;
                else
                    chosen = I2p - 1;
                end;
        end;
    end;

    position = sign((polylineX(chosen+1) - polylineX(chosen)) * (point(2) - polylineY(chosen)) -...
                    (polylineY(chosen+1) - polylineY(chosen)) * (point(1) - polylineX(chosen)));

    if position == 1
        plot(point(1),point(2),'r.','MarkerSize',5)
    elseif position == -1;
        plot(point(1),point(2),'.','Color',[0.9 0.9 0.9],'MarkerSize',5) % gray color
    elseif position == 0
        plot(point(1),point(2),'k.','MarkerSize',5)
    elseif position == -2
        plot(point(1),point(2),'g.','MarkerSize',5)
    end;

    pause(0.00000001)
    clear chosen  count_s distance2p distance 2s flag I2p I2s minimum2p minimum2s point pos1 pos2 position

end;
end;

Answer 1

基于＆＃34; winding number＆＃34;的概念，替代解决方案怎么样？这将涉及计算从测试点看到的边界折线的所有线段所对应的总角度。

如果您想象这条折线在无穷远处被半圆扩展以形成闭合轮廓，那么对于轮廓外的点，这个角度的总和将为零，但对于内部点，该角度将为2 * Pi。显然，半圆是在左半平面还是右半平面将确定线的哪一侧是＆＃34;内部＆＃34;或＆＃34;外面＆＃34;。如果从角度和中排除半圆本身，因为它贡献+/- Pi，那么线的一侧上的点应该具有+ Pi的角度和，而另一侧应该给出-Pi。它是+ Pi还是-Pi取决于折线中顶点序列定义的方向。

这种方法的一个微妙之处在于计算折线的每个片段所对应的（带符号）角度。我相信这可以通过查看将测试点连接到给定段的两端的两个向量来完成。通过获取这些向量的点积（并在除以它们的长度之后），您可以计算该段所针对的角度的余弦。在负角度的正值之间取反余弦将是模糊的。但是，通过取两个向量的cross-product（将它们的z分量视为零），您可以计算角度的正弦值，其符号将允许您计算反余弦的正确分支。

Answer 2

天真的想法是从点到线整合角度。积分从无穷远处的一侧开始，然后从所有点开始到无穷远的另一侧。这只是一堆atan2函数。

曲线的一侧是从积分的符号确定的。即使曲线重叠，这也应该有效。

在python中：

from math import atan2,pi
#import matplotlib.pyplot as plt

# difference of two angles should be always -pi < x < pi
def fixed_angle(a):
    if a > pi:
       return a - 2*pi
    elif a < (-1*pi):
       return a + 2*pi
    assert(-1*pi < a < pi) # just check, to be sure
    return a

# polyline
xs = [0, 1, 2, 3, 4, 5, 6, 7, 8];
ys = [-10, 20, -13, 18, -17, 16, -21, 23, -25];

# start point
x = 4
y = 0

#from first two points
angle_start = atan2(ys[0]-ys[1],xs[0]-xs[1])
#last angle is angle of last section
angle_end = atan2(ys[-1]-ys[-2],xs[-1]-xs[-2]) 

integ = 0
prev =  angle_start
for i in range(len(xs)):
    a = atan2(ys[i]-y,xs[i]-x)
    integ += fixed_angle(a-prev)
    prev = a

integ += fixed_angle(angle_end - prev)

if integ > 0:
    print("point is left")
else:
    print("point is right")

#plt.plot(xs,ys)
#plt.show()

Answer 3

一种不计算角度的方法是考虑由测试点和连续的折线段组成的三角形的有符号区域。

（按照您的约定），三角形的有符号区域可以理解为一个顶点位于相对线的“左侧”或“右侧”。它由公式0.5 * (-x2*y1 + x3*y1 + x1*y2 - x3*y2 -x1*y3 + x2*y3)为三个顶点(xi, yi)计算。至关重要的是，遍历顶点的顺序会影响符号。

将折线设置为列表[v1, v2, ...., vn]。对于每个有序对的相邻顶点(v_i, v_(i+1))，计算三角形(v_i, your-test-point, v_(i+1))的有符号面积。似乎需要考虑“边”决策的地方是绝对面积最小的三角形：即，该点距折线“最近”。根据惯例，考虑折线的有符号面积，确定该三角形相对于折线是左侧还是右侧。

* edit-零面积三角形表示您的测试点与多段线共线；您需要分别测试它是否确实在细分市场上。

Answer 4

我的解决方案在图中是不言自明的。

投影点，例如P ₁到折线[O ₁，O ₂，O ₃，O ₄]，投影点为P ^' ₁，它位于线O ₁ O ₂。 / li>
如果O ₁ P ^' ₁ P ₁和P ₁ P ^' ₁ O ₂均为逆时针方向，则点P ₁位于对象的左侧。折线。
如果折线右侧的点（例如P ₂），则O ₃ P ^' _{2 < / sub> P ₂和P ₂ P ^' ₂ O ₄顺时针方向。}

折线的哪一边是一个点

4 个答案: