使用相邻像素叉积从深度图像计算表面法线

Question

正如标题所说，我想通过使用相邻像素的叉积来计算给定深度图像的表面法线。我想为此使用 Opencv 并避免使用 PCL 但是，我并不真正理解该过程，因为我在该主题上的知识非常有限。因此，如果有人可以提供一些提示，我将不胜感激。在这里提一下，除了深度图和对应的rgb图，我没有其他信息，所以没有K相机矩阵信息。

因此，假设我们有以下深度图像：

并且我想在具有相应深度值的相应点处找到法向量，如下图所示：

如何使用相邻像素的叉积来做到这一点？如果法线不是很准确，我不介意。

谢谢。

更新：

好的，我试图按照@timday 的回答并将他的代码移植到 Opencv。使用以下代码：

Mat depth = <my_depth_image> of type CV_32FC1
Mat normals(depth.size(), CV_32FC3);

for(int x = 0; x < depth.rows; ++x)
{
    for(int y = 0; y < depth.cols; ++y)
    {

        float dzdx = (depth.at<float>(x+1, y) - depth.at<float>(x-1, y)) / 2.0;
        float dzdy = (depth.at<float>(x, y+1) - depth.at<float>(x, y-1)) / 2.0;

        Vec3f d(-dzdx, -dzdy, 1.0f);
        Vec3f n = normalize(d);

        normals.at<Vec3f>(x, y) = n;
    }
}

imshow("depth", depth / 255);
imshow("normals", normals);

我得到了正确的以下结果（我不得不将 double 替换为 float 并将 Vecd 替换为 Vecf，我不知道为什么会这样虽然有区别）：

Answer 1

您实际上不需要为此使用叉积，但请参阅下文。

考虑你的距离图像是一个函数 z(x,y)。

曲面的法线方向为(-dz/dx,-dz/dy,1)。（dz/dx 我的意思是微分：z 随 x 的变化率）。然后法线按惯例归一化为单位长度。

顺便说一下，如果您想知道 (-dz/dx,-dz/dy,1) 是从哪里来的...如果您将平面中的 2 个正交切向量与x 和 y 轴，它们是 (1,0,dzdx) 和 (0,1,dzdy)。法线垂直于切线，所以应该是 (1,0,dzdx)X(0,1,dzdy) - 其中 'X' 是 cross-product - 即 (-dzdx,-dzdy,1 ).所以这是你的叉积派生法线，但是当你可以直接使用法线的结果表达式时，几乎不需要在代码中如此明确地计算它。

计算 (x,y) 处的 unit-length 法线的伪代码类似于

dzdx=(z(x+1,y)-z(x-1,y))/2.0;
dzdy=(z(x,y+1)-z(x,y-1))/2.0;
direction=(-dzdx,-dzdy,1.0)
magnitude=sqrt(direction.x**2 + direction.y**2 + direction.z**2)
normal=direction/magnitude

根据您要执行的操作，将 NaN 值替换为较大的数字可能更有意义。

使用这种方法，从你的距离图像中，我可以得到这个：

（然后我使用计算出的法线方向进行一些简单的着色；请注意由于范围图像的量化而出现的 "steppy" 外观；理想情况下，您的精度比 8 位更高范围数据）。

抱歉，不是 OpenCV 或 C++ 代码，只是为了完整起见：生成该图像的完整代码（嵌入 Qt QML 文件中的 GLSL；可以运行与 Qt5 的 qmlscene）如下。上面的伪代码可以在片段着色器的main()函数中找到：

import QtQuick 2.2

Image {
  source: 'range.png'  // The provided image

  ShaderEffect {
    anchors.fill: parent
    blending: false

    property real dx: 1.0/parent.width
    property real dy: 1.0/parent.height
    property variant src: parent

    vertexShader: "
      uniform highp mat4 qt_Matrix;
      attribute highp vec4 qt_Vertex;
      attribute highp vec2 qt_MultiTexCoord0;
      varying highp vec2 coord;
      void main() {
        coord=qt_MultiTexCoord0;
        gl_Position=qt_Matrix*qt_Vertex;
      }"

   fragmentShader: "
     uniform highp float dx;
     uniform highp float dy;
     varying highp vec2 coord;
     uniform sampler2D src;
     void main() {
       highp float dzdx=( texture2D(src,coord+vec2(dx,0.0)).x - texture2D(src,coord+vec2(-dx,0.0)).x )/(2.0*dx);
       highp float dzdy=( texture2D(src,coord+vec2(0.0,dy)).x - texture2D(src,coord+vec2(0.0,-dy)).x )/(2.0*dy);
       highp vec3 d=vec3(-dzdx,-dzdy,1.0);
       highp vec3 n=normalize(d);
       highp vec3 lightDirection=vec3(1.0,-2.0,3.0);
       highp float shading=0.5+0.5*dot(n,normalize(lightDirection));
       gl_FragColor=vec4(shading,shading,shading,1.0);
     }"
  }
}

Answer 2

我认为正确的代码（矩阵计算）：

def normalization(data):
   mo_chang =np.sqrt(np.multiply(data[:,:,0],data[:,:,0])+np.multiply(data[:,:,1],data[:,:,1])+np.multiply(data[:,:,2],data[:,:,2]))
   mo_chang = np.dstack((mo_chang,mo_chang,mo_chang))
   return data/mo_chang

x,y=np.meshgrid(np.arange(0,width),np.arange(0,height))
x=x.reshape([-1])
y=y.reshape([-1])
xyz=np.vstack((x,y,np.ones_like(x)))
pts_3d=np.dot(np.linalg.inv(K),xyz*img1_depth.reshape([-1]))
pts_3d_world=pts_3d.reshape((3,height,width))
f= pts_3d_world[:,1:height-1,2:width]-pts_3d_world[:,1:height-1,1:width-1]
t= pts_3d_world[:,2:height,1:width-1]-pts_3d_world[:,1:height-1,1:width-1]
normal_map=np.cross(f,l,axisa=0,axisb=0)
normal_map=normalization(normal_map)
normal_map=normal_map*0.5+0.5
alpha = np.full((height-2,width-2,1), (1.), dtype="float32")
normal_map=np.concatenate((normal_map,alpha),axis=2)

我们应该使用名为 'K' 的相机内部函数。我认为值 f 和 t 是基于相机坐标中的 3D 点。
对于法线向量，(-1,-1,100)和(255,255,100)在8位图像中是相同的颜色，但它们是完全不同的法线。所以我们应该通过 normal_map=normal_map*0.5+0.5.
将正常值映射到 (0,1)

欢迎交流

使用相邻像素叉积从深度图像计算表面法线

Calculate surface normals from depth image using neighboring pixels cross product

c++

opencv

normals

depth

cross-product