Question

我写了一个python脚本，它从查询点（p）中找到表面上最近点的UV坐标。表面由四个线性边缘定义，这四个线性边缘由逆时针列出的四个已知点（p0，p1，p2，p3）组成。

（请忽略小红球）

我的方法的问题是它非常慢（使用低精度阈值进行5000次查询约10秒。

我正在寻找一种更好的方法来实现我想要的，或者建议使我的代码更有效率。我唯一的限制是它必须用python编写。

import numpy as np

# Define constants
LARGE_VALUE=99999999.0
SMALL_VALUE=0.00000001
SUBSAMPLES=10.0

def closestPointOnLineSegment(a,b,c):
    ''' Given two points (a,b) defining a line segment and a query point (c)
        return the closest point on that segment, the distance between
        query and closest points, and a u value derived from the results
    '''

    # Check if c is same as a or b
    ac=c-a
    AC=np.linalg.norm(ac)
    if AC==0.:
        return c,0.,0.

    bc=c-b
    BC=np.linalg.norm(bc)
    if BC==0.:
        return c,0.,1.


    # See if segment length is 0
    ab=b-a
    AB=np.linalg.norm(ab)
    if AB == 0.:
        return a,0.,0.

    # Normalize segment and do edge tests
    ab=ab/AB
    test=np.dot(ac,ab)
    if test < 0.:
        return a,AC,0.
    elif test > AB:
        return b,BC,1.

    # Return closest xyz on segment, distance, and u value
    p=(test*ab)+a
    return p,np.linalg.norm(c-p),(test/AB)




def surfaceWalk(e0,e1,p,v0=0.,v1=1.):
    ''' Walk on the surface along 2 edges, for each sample segment
        look for closest point, recurse until the both sampled edges
        are smaller than SMALL_VALUE
    '''

    edge0=(e1[0]-e0[0])
    edge1=(e1[1]-e0[1])
    len0=np.linalg.norm(edge0*(v1-v0))
    len1=np.linalg.norm(edge1*(v1-v0))

    vMin=v0
    vMax=v1
    closest_d=0.
    closest_u=0.
    closest_v=0.
    ii=0.
    dist=LARGE_VALUE

    for i in range(int(SUBSAMPLES)+1):
        v=v0+((v1-v0)*(i/SUBSAMPLES))
        a=(edge0*v)+e0[0]
        b=(edge1*v)+e0[1]

        closest_p,closest_d,closest_u=closestPointOnLineSegment(a,b,p)

        if closest_d < dist:
            dist=closest_d
            closest_v=v
            ii=i

    # If both edge lengths <= SMALL_VALUE, we're within our precision treshold so return results
    if len0 <= SMALL_VALUE and len1 <= SMALL_VALUE:
        return closest_p,closest_d,closest_u,closest_v

    # Threshold hasn't been met, set v0 anf v1 limits to either side of closest_v and keep recursing
    vMin=v0+((v1-v0)*(np.clip((ii-1),0.,SUBSAMPLES)/SUBSAMPLES))
    vMax=v0+((v1-v0)*(np.clip((ii+1),0.,SUBSAMPLES)/SUBSAMPLES))
    return surfaceWalk(e0,e1,p,vMin,vMax)




def closestPointToPlane(p0,p1,p2,p3,p,debug=True):
    ''' Given four points defining a quad surface (p0,p1,p2,3) and
        a query point p. Find the closest edge and begin walking
        across one end to the next until we find the closest point 
    '''

    # Find the closest edge, we'll use that edge to start our walk
    c,d,u,v=surfaceWalk([p0,p1],[p3,p2],p)
    if debug:
        print 'Closest Point:     %s'%c
        print 'Distance to Point: %s'%d
        print 'U Coord:           %s'%u
        print 'V Coord:           %s'%v

    return c,d,u,v



p0 = np.array([1.15, 0.62, -1.01])
p1 = np.array([1.74, 0.86, -0.88])
p2 = np.array([1.79, 0.40, -1.46])
p3 = np.array([0.91, 0.79, -1.84])
p =  np.array([1.17, 0.94, -1.52])
closestPointToPlane(p0,p1,p2,p3,p)


Closest Point:     [ 1.11588876  0.70474519 -1.52660706]
Distance to Point: 0.241488104197
U Coord:           0.164463481066
V Coord:           0.681959858995

Answer 1

如果您的表面看起来像双曲抛物面，则可以将其上的点s参数化为：

s = p0 + u * (p1 - p0) + v * (p3 - p0) + u * v * (p2 - p3 - p1 + p0)

以这种方式做事，行p0p3包含等式u = 0，p1p2为u = 1，p0p1为v = 0且{{1是p2p3。我无法找到一种方法来得出最接近点v = 1的分析表达式，但是p可以为你做数字工作：

scipy.optimize

import numpy as np from scipy.optimize import minimize p0 = np.array([1.15, 0.62, -1.01]) p1 = np.array([1.74, 0.86, -0.88]) p2 = np.array([1.79, 0.40, -1.46]) p3 = np.array([0.91, 0.79, -1.84]) p = np.array([1.17, 0.94, -1.52]) def fun(x, p0, p1, p2, p3, p): u, v = x s = u*(p1-p0) + v*(p3-p0) + u*v*(p2-p3-p1+p0) + p0 return np.linalg.norm(p - s) >>> minimize(fun, (0.5, 0.5), (p0, p1, p2, p3, p)) status: 0 success: True njev: 9 nfev: 36 fun: 0.24148810420527048 x: array([ 0.16446403, 0.68196253]) message: 'Optimization terminated successfully.' hess: array([[ 0.38032445, 0.15919791], [ 0.15919791, 0.44908365]]) jac: array([ -1.27032399e-06, 6.74091280e-06])的返回是一个对象，您可以通过其属性访问值：

minimize

关于如何在没有scipy的情况下寻找解决方案的一些指示...如上所述参数化的点>>> res = minimize(fun, (0.5, 0.5), (p0, p1, p2, p3, p)) >>> res.x # u and v coordinates of the nearest point array([ 0.16446403, 0.68196253]) >>> res.fun # minimum distance 0.24148810420527048的向量与通用点s是p。要找出最接近的点，您可以采用两种不同的方式来得到相同的结果：

计算该向量的长度p-s，取其衍生物w.r.t. (p-s)**2和u并将它们等同为零。
计算与v处的hypar相切的两个向量，可以找到s和ds/du，并强制其ds/dv的内积为零。< / LI>
如果你解决这些问题，你最终会得到两个方程式，这些方程需要大量的操作才能达到p-s或u的三度或四度方程式，所以没有确切的分析解决方案，尽管你只能通过numpy以数字方式解决这个问题。一个更简单的选择是计算出这些方程式，直到得到这两个方程，其中v，a = p1-p0，b = p3-p0，c = p2-p3-p1+p0，s_ = s-p0：
```
p_ = p-p0
```
你不能轻易地为此提出一个分析解决方案，但你可以希望，如果你使用这两个关系迭代一个试验解决方案，它将会收敛。对于您的测试用例，它确实有效：
```
u = (p_ - v*b)*(a + v*c) / (a + v*c)**2
v = (p_ - u*a)*(b + u*c) / (b + u*c)**2
```
我不认为这可以保证收敛，但对于这种特殊情况，它似乎工作得很好，只需要15次迭代才能达到要求的容差。

加速双曲抛物面算法的最近点

1 个答案: