相关疑难解决方法(0)

我有一个描述Point的类(有2个坐标x和y)和一个描述Polygon的类,它有一个对应于角的列表(self.corners)我需要检查Point是否在多边形中

这是应该检查多边形中的Point in的函数.我正在使用Ray Casting Method

def in_me(self, point):
        result = False
        n = len(self.corners)
        p1x = int(self.corners[0].x)
        p1y = int(self.corners[0].y)
        for i in range(n+1):
            p2x = int(self.corners[i % n].x)
            p2y = int(self.corners[i % n].y)
            if point.y > min(p1y,p2y):
                if point.x <= max(p1x,p2x):
                    if p1y != p2y:
                        xinters = (point.y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
                        print xinters
                    if p1x == p2x or point.x <= xinters:
                        result = not result
            p1x,p1y = p2x,p2y
         return result

我运行了一个具有以下形状和点的测试:

PG1 = (0,0), (0,2), (2,2), (2,0)
point = (1,1)

即使该行内的点,该脚本也会愉快地返回False.我无法找到错误

我希望能够看到 3D 表面上的线（和点）位于表面顶部（第二张图像），而不是后面（第一张图像）。这是我的 3D 函数：

def f(x, y): 
    return np.sin(2*x) * np.cos(2*y)

3D 表面的 X、Y、Z：

x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)

我生成了 x 点 (xx) 和 y 点 (yy) 的向量，其中 zz = f(xx,yy)

fig = plt.figure(figsize=(8,6))
ax = plt.axes(projection='3d')
ax.scatter(xx, yy, zz, c='r', marker='o')
#ax.plot(xx,yy,zz, c= 'r')

ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                cmap='viridis', edgecolor='none')

正如你所看到的，点在图后面，图形覆盖了点。我想看看情节上的要点。我应该怎么办？

我希望能够看到像这样的点和线：

编辑：这是我生成点的方式：

for i in range(1,2000):
    [a, b] =  np.random.rand(2,1)*np.sign(np.random.randn(2,1))*2
    xx = …

VI 在图像上绘制了一组轮廓点，并将其存储为 2D numpy 数组。轮廓由 2 个 numpy 数组表示，每个数组的 x 和 y 坐标为浮点值。这些坐标不是整数，并且不能与像素完美对齐，但它们确实可以告诉您轮廓点相对于像素的位置。

我希望能够选择轮廓内的像素。我编写了一些与此处给出的答案几乎相同的代码：使用 Python 中的 OpenCV 在轮廓边界内访问像素值

temp_list = []
for a, b in zip(x_pixel_nos, y_pixel_nos):
    temp_list.append([[a, b]]) # 2D array of shape 1x2
temp_array = np.array(temp_list)
contour_array_list = []
contour_array_list.append(temp_array)



lst_intensities = []

# For each list of contour points...
for i in range(len(contour_array_list)):
    # Create a mask image that contains the contour filled in
    cimg = np.zeros_like(pixel_array)
    cv2.drawContours(cimg, contour_array_list, i, color=255, thickness=-1)

# Access …

这似乎是一个重复的问题，但是我尝试了已经存在的解决方案，但到目前为止，对于我来说似乎没有任何解决方案。。

该解决方案给出了提示，但仅适用于常规几何体。我有一个相当复杂的几何图形，可以从中提取未排序的边界点。

下面是我从几何图形中提取的几何图形和边界顶点的图片。

如图所示，点的（x，y）坐标为：

import numpy as np

pts = np.array([[  30.        ,   -6.25      ],
                [  30.        ,   -8.10127917],
                [   0.        ,   -6.25      ],
                [  34.14082772,   -6.75584268],
                [  36.49784598,  -10.        ],
                [  44.43561524,  -10.        ],
                [ 100.        ,  -10.        ],
                [ 100.        ,   10.        ],
                [  84.1244615 ,  -10.        ],
                [  84.1244615 ,   10.        ],
                [  36.49784598,   10.        ],
                [  34.14082772,    6.75584268],
                [  44.43561524,   10.        ],
                [  30.        ,    8.10127917],
                [  30.        ,    6.25      ],
                [   0.        ,    6.25 …

我有这个数据框，其中包含纬度/经度坐标：

      Lat       Lon
 29.39291 -98.50925
 29.39923 -98.51256
 29.40147 -98.51123
 29.38752 -98.52372
 29.39291 -98.50925
 29.39537 -98.50402
 29.39343 -98.49707
 29.39291 -98.50925
 29.39556 -98.53148

这些是构造多边形的坐标：

       Lat        Lon
 29.392945 -98.507696
 29.406167 -98.509074
 29.407234 -98.517039
 29.391325 -98.517166

我想使用 Python 检查每个坐标（来自第一个数据帧）是否在多边形内，并考虑到大圆。

预期结果：

      Lat       Lon  Within
 29.39291 -98.50925       1
 29.39923 -98.51256       1
 29.40147 -98.51123       1
 29.38752 -98.52372       0
 29.39291 -98.50925       1
 29.39537 -98.50402       0
 29.39343 -98.49707       0
 29.39291 -98.50925       1
 29.39556 -98.53148       0

我画了一个极端点周围的轮廓.里面的多边形图我有其他点.如何检查它们是否在轮廓内？

我有一个函数可以在多边形测试中执行一个点。它需要两个 2D numpy 数组作为输入（一系列点和一个多边形）。该函数返回一个布尔值作为输出（如果点位于多边形内，则为 True，否则为 False）。代码是从这个 SO answer借来的。下面是一个例子：

from numba import jit
from numba.pycc import CC
cc = CC('nbspatial')
import numpy as np

@cc.export('array_tracing2', 'b1[:](f8[:,:], f8[:,:])')
@jit(nopython=True, nogil=True)
def array_tracing2(xy, poly):
    D = np.empty(len(xy), dtype=numba.boolean)
    n = len(poly)
    for i in range(1, len(D) - 1):
        inside = False
        p2x = 0.0
        p2y = 0.0
        xints = 0.0
        p1x,p1y = poly[0]
        x = xy[i][0]
        y = xy[i][1]
        for i in range(n+1):
            p2x,p2y = poly[i % n]
            if y > …

我正在开发一个需要坐标映射的项目 - 确定坐标点是否存在于一系列多边形中。映射的数量相当大 - 跨越 100 多个多边形的约 1000 万个坐标。

在继续之前，我已经查看了此处和此处的问题。这个问题并不多余，因为它涉及动态点和静态多边形。

我通过在 200 万个多边形的子集中映射单个坐标来缩小该问题的项目范围。这是我使用的代码：

from shapely.geometry import shape, Point

f = open('path/to/file.geojson', 'r')
data = json.loads(f.read())

point = Point(42.3847, -71.127411)
for feature in data['features']:
    polygon = shape(feature['geometry'])
    if polygon.contains(point):
        print(polygon)

迭代 200 万个多边形（在本例中为建筑足迹）大约需要 30 秒（时间太长）。

我也尝试过使用mplPath如下：

import matplotlib.path as mplPath

building_arrays = [np.array(data['features'][i]['geometry']['coordinates'][0])
                   for i, v in enumerate(tqdm(data['features']))]
bbPath_list = [mplPath.Path(building)
               for building in tqdm(building_arrays)]

for b in tqdm(bbPath_list):
    if b.contains_point((-71.1273842, 42.3847423)):
        print(b)

这大约需要 6 秒。一个改进，但考虑到我需要的映射量，仍然有点慢。 …