python-3.x - 如何在另一个 np.where 中使用 np.where (conext : ray tracing)

Question

问题是:如何在同一个语句中使用两个 np.where，如下所示(过于简化):

np.where((ndarr1==ndarr2),np.where((ndarr1+ndarr2==ndarr3),True,False),False)

如果未达到第一个条件语句，则避免计算第二个条件语句。

我的第一个目标是找到三角形中射线的交点(如果有的话)。这个问题可以通过这个算法解决(在stackoverflow上找到):

def intersect_line_triangle(q1,q2,p1,p2,p3):
    def signed_tetra_volume(a,b,c,d):
        return np.sign(np.dot(np.cross(b-a,c-a),d-a)/6.0)

    s1 = signed_tetra_volume(q1,p1,p2,p3)
    s2 = signed_tetra_volume(q2,p1,p2,p3)

    if s1 != s2:
        s3 = signed_tetra_volume(q1,q2,p1,p2)
        s4 = signed_tetra_volume(q1,q2,p2,p3)
        s5 = signed_tetra_volume(q1,q2,p3,p1)
        if s3 == s4 and s4 == s5:
           n = np.cross(p2-p1,p3-p1)
           t = np.dot(p1-q1,n) / np.dot(q2-q1,n)
           return q1 + t * (q2-q1)
    return None

这里有两个条件语句:

1. s1!=s2
2. s3==s4 & s4==s5

现在，由于我有 >20k 个三角形需要检查，我想同时对所有三角形应用此函数。

第一个解决方案是:

s1 = vol(r0,tri[:,0,:],tri[:,1,:],tri[:,2,:])
s2 = vol(r1,tri[:,0,:],tri[:,1,:],tri[:,2,:])

s3 = vol(r1,r2,tri[:,0,:],tri[:,1,:])
s4 = vol(r1,r2,tri[:,1,:],tri[:,2,:])
s5 = vol(r1,r2,tri[:,2,:],tri[:,0,:])

np.where((s1!=s2) & (s3+s4==s4+s5),intersect(),False)

其中 s1、s2、s3、s4、s5 是包含每个三角形的值 S 的数组。问题是，这意味着我必须计算所有三角形的 s3、s4 和 s5。

现在理想的情况是仅当语句 1 为 True 时才计算语句 2(以及 s3、s4、s5)，如下所示:

check= np.where((s1!=s2),np.where((compute(s3)==compute(s4)) & (compute(s4)==compute(s5), compute(intersection),False),False)

(为了简化说明，我只是说“计算”而不是整个计算过程。这里，“计算”只在适当的三角形上进行)。

现在这个选项当然不起作用(并且计算 s4 两次)，但我很乐意对类似过程提出一些建议

Answer 1

以下是我如何使用掩码数组来解决这个问题:

    loTrue= np.where((s1!=s2),False,True)
    s3=ma.masked_array(np.sign(dot(np.cross(r0r1, r0t0), r0t1)),mask=loTrue)
    s4=ma.masked_array(np.sign(dot(np.cross(r0r1, r0t1), r0t2)),mask=loTrue)
    s5=ma.masked_array(np.sign(dot(np.cross(r0r1, r0t2), r0t0)),mask=loTrue)
    loTrue= ma.masked_array(np.where((abs(s3-s4)<1e-4) & ( abs(s5-s4)<1e-4),True,False),mask=loTrue)

    #also works when computing s3,s4 and s5 inside loTrue, like this:        
    loTrue= np.where((s1!=s2),False,True)
    loTrue= ma.masked_array(np.where(
            (abs(np.sign(dot(np.cross(r0r1, r0t0), r0t1))-np.sign(dot(np.cross(r0r1, r0t1), r0t2)))<1e-4) &
            (abs(np.sign(dot(np.cross(r0r1, r0t2), r0t0))-np.sign(dot(np.cross(r0r1, r0t1), r0t2)))<1e-4),True,False)
            ,mask=loTrue)

请注意，当不使用这种方法时，相同的过程是这样完成的:

    s3= np.sign(dot(np.cross(r0r1, r0t0), r0t1)  /6.0)
    s4= np.sign(dot(np.cross(r0r1, r0t1), r0t2)  /6.0)
    s5= np.sign(dot(np.cross(r0r1, r0t2), r0t0)  /6.0)
    loTrue= np.where((s1!=s2) & (abs(s3-s4)<1e-4) & ( abs(s5-s4)<1e-4) ,True,False)

两者给出相同的结果，但是，当仅在此过程中循环 10k 次迭代时，不使用掩码数组会更快! (没有屏蔽数组时为 26 秒，使用屏蔽数组时为 31 秒，仅在一行中使用屏蔽数组时为 33 秒(不单独计算 s3、s4 和 s5，或之前计算 s4)。

结论:这里解决了使用嵌套数组的问题(请注意，掩码指示不会计算它的位置，因此当条件得到验证时，第一个 loTri 必须设置为 False (0))。然而，在这种情况下，它并没有更快。