Python 搜索坐标是否位于立方体内部的最快方法

在我的代码中，我不断地接收三维整数坐标（x，y，z）流。必须对照区域列表检查每个坐标，以查看它是否位于这些区域中。每个区域由相对的高坐标和低坐标定义。如果代码发现坐标位于某个区域，它将采取进一步的操作，否则它将退出以继续查找与另一个区域的匹配，或者如果没有匹配的区域，则完全退出

由于这种情况发生得如此之快，我想尽快浏览整个区域列表，创建一个匹配，或者确定它与任何区域都不匹配，然后转到下一个坐标。我目前所做的工作“有效”，并且（对我来说）很好且可读，但需要一些优化：

firstcorner = self.regions["regions"][name]["pos1"]
secondcorner = self.regions["regions"][name]["pos2"]
Xmin = firstcorner[0] - 1  # XXXXXXX
Ymin = firstcorner[1] - 1
Zmin = firstcorner[2] - 1
Xmax = secondcorner[0] + 1  # XXXXXXXX
Ymax = secondcorner[1] + 1
Zmax = secondcorner[2] + 1
BX = position[0]  # XXXXXXX
BY = position[1]
BZ = position[2]
inX = (BX > Xmin) and (BX < Xmax)  # XXXXXXXX
inZ = (BZ > Zmin) and (BZ < Zmax)
inY = (BY > Ymin) and (BY < Ymax)
if inX and inY and inZ: 

firstcorner=self.regions[“regions”][name][“pos1”]
secondcorner=self.regions[“regions”][name][“pos2”]
Xmin=firstcorner[0]-1#XXXXXXX
Ymin=firstcorner[1]-1
Zmin=firstcorner[2]-1
Xmax=secondcorner[0]+1#XXXXXXXX
Ymax=第二角[1]+1
Zmax=secondcorner[2]+1
BX=位置[0]#XXXXXXX
BY=位置[1]
BZ=位置[2]
inX=（BX>Xmin）和（BXZmin）和（BZYmin）和（BY

我考虑将其嵌套，使其首先匹配X项；如果X落在坐标范围内，然后试着看看Z，最后是Y

---

如何创建最快的Python 2.7代码

您可以使用

all

将条件连接在一起（并适当地短路）

def point_inside(rectangle, point):
    firstcorner, secondcorner = rectangle
    xmin, xmax = firstcorner[0]-1, secondcorner[0]+1
    yield xmin < point[0] < xmax
    ymin, ymax = firstcorner[1]-1, secondcorner[1]+1
    yield ymin < point[1] < ymax
    zmin, zmax = firstcorner[2]-1, secondcorner[2]+1
    yield zmin < point[2] < zmax

rect = (firstcorner, secondcorner)

if all(point_inside(rect, position)):
    # it's inside the cube

def point_内部（矩形，点）：
第一个角点，第二个角点=矩形
xmin，xmax=firstcorner[0]-1，secondcorner[0]+1
收益率xmin<点[0]

然而，如果您只编写一些类定义并将它们称为对象，那么这将更容易理解

class Rectangle(object):
    def __init__(self, xrange, yrange, zrange):
        self.xrange = xrange  # (xmin, xmax)
        self.yrange = yrange
        self.zrange = zrange

    def contains_point(self, p):
        if not all(hasattr(p, loc) for loc in 'xyz'):
            raise TypeError("Can only check if 3D points are in the rect")
        return all([self.xrange[0] <= p.x <= self.xrange[1],
                    self.yrange[0] <= p.y <= self.yrange[1]
                    self.zrange[0] <= p.z <= self.zrange[1]])

    # BONUS!
    @classmethod
    def from_points(cls, firstcorner, secondcorner):
        """Builds a rectangle from the bounding points

        Rectangle.from_points(Point(0, 10, -10),
                              Point(10, 20, 0)) == \
                Rectangle((0, 10), (10, 20), (-10, 0))

        This also works with sets of tuples, e.g.:
        corners = [(0, 10, -10), (10, 20, 0)]
        Rectangle.from_points(*corners) == \
                Rectangle((0, 10), (10, 20), (-10, 0))
        """
        return cls(*zip(firstcorner, secondcorner))

class Point(object):
    def __init__(self, x, y z):
        self.x = x
        self.y = y
        self.z = z

    def __iter__(self): 
        yield from (self.x, self.y, self.z)

rect = Rectangle((0, 10), (10, 20), (-10, 0))
# firstpoint, secondpoint in this analogy would be:
# # (0, 10, -10), (10, 20, 0)
inside_point = Point(3, 15, -8)
outside_point = Point(11, 15, -8)

rect.contains_point(inside_point)  # True
rect.contains_point(outside_point)  # False

类矩形（对象）：
定义初始值（自、X量程、Y量程、Z量程）：
self.xrange=xrange#（xmin，xmax）
self.yrange=yrange
self.zrange=zrange
def包含_点（自身，p）：
如果不是全部（hasattr（p，loc）表示“xyz”中的loc）：
raise TypeError（“只能检查三维点是否在矩形中”）
当您检查坐标是否位于需要计算六个比较（每个边界一个）的区域时，返回all（[self.xrange[0]1.1）。一个可能有帮助的想法是嵌套所述比较，以便如果其中一个为假，则不必检查其他。平均而言，您将在每个区域计算不到六个比较（可能是三个？）.以下是伪代码示例：

# for a region that has the following bounds: ((X1,X2),(Y1,Y2),(Z1,Z2))
if(check X1):
  if(check X2):
    if(check Y1):
      if(check Y2):
        if(check Z1):
          if(check Z2):
            return "found it!!"

考虑一维坐标空间的情况（仅x轴）分为N个区域。在问题中公布的方法中，每个区域需要进行2次比较，总计2N次比较。使用提出的方法，平均1.5N次比较。对于N³相同立方区域形成更大的N边区域立方体的情况，最初需要6N³比较，现在您需要进行2N³+3N²+3N+1比较

1.2）如果共享相同边界的区域嵌套在相同条件下，则可以计算较少的比较。例如：

# regions A and B share bounds (X1,X2)
if(check X1):
  if(check X2):
    if(check Y1):
      if(check Y2):
        if(check Z1):
          if(check Z2):
            return "found it in region A!!"
    if(check Y3):
      if(check Y4):
        if(check Z3):
          if(check Z4):
            return "found it in region B!!"

在立方体区域形成更大立方体的情况下，这将显著降低计算成本，但我没有费心进行计算

2） 您完全可以通过使用来加快区域列表中的搜索速度（如果区域没有像立方体区域案例中那样高度组织，则特别有用）。我的建议是，将区域索引为属于父区域。检查坐标是否在父区域中；如果在父区域中，则仅检查其是否属于在所述父区域下索引的区域。在某种程度上，这在概念上类似于（1.2）中所做的操作
我发现的最简单的方法是通过检查任何坐标是否大于任意两个角来询问点是否在立方体的之外：

将numpy导入为np
def inCube（X，角）：
"""
检查点“X”是否位于带“角”的矩形监狱内（两点）
"""
#X>角在哪里？
更大=X>角点
#如果X大于任何轴的两个角，则它位于外侧
内部=~np.any（np.equal（*更大））
角点=[[0,0,0]，[1,1,1]]
Xs=np.array（[.5,5,5]，
[-.5, .5, .5]])
[X中X的inCube（X，角）]#[True，False]
那里没有短路。在输入
All
@Javier之前对所有参数进行评估。这真的不重要。在任何不是50年代的计算机上，性能差异可以忽略不计。
All
短路。
Ymin你错了，我的朋友。看：
All（0>1，1i>2i）
。即使第一个比较为假，它也会对第二个比较进行评估。更简洁的方法是使用生成器和直接比较列表：
all（下角您的伪代码正在推广非常糟糕的做法-您绝对不应该如图所示嵌套
if
s。请注意，python中的
和
运算符默认短路，因此可以简化为
if（检查x1）和（检查x2）和…
。即使这样，也只应用于某些性能极其关键的情况（无论如何，在外部C库中处理这些情况会更好），为了可读性，如果有几个以上的情况，一般应该将
all
函数与生成器一起使用。我不知道。这肯定排除了1.1。是否有可能实现1.2中的想法而不陷入如此糟糕的实践中？（这有意义吗？）。搜索树（2）仍然可以使用