The estimation of point normals is vital for accurate 3D meshing of point clouds, as normals give additional information on curvature and enable smoother non-linear mesh interpolation. Thus, a critical step in the computer vision pipeline of the MOCI satellite is to estimate point normals. Though point cloud meshing is not currently implemented int the MOCI computer vision software, it should be considered reasonable future work.

Aside from the point cloud coordinates, the only information needed in the point normal calculation is the camera position which generated each point. The final result will be the same list of input point coordinates along with the computed normal vector of each point. The problem of determining the normal to a point on the surface is approximated by estimating the tangent plane of the point, and then taking the normal vector to the plane. However, there are two valid normals for estimated tangent plane but only one is suitable for reconstruction. The correct orientation of the normal vector cannot be directly inferred, so an additional subroutine is needed to choose the correct normal vector.

Let a given point cloud be referenced as where a given point is and for each point we seek to find the correct normal vector . Also note that each point has an associated camera of the form .

First, the nearest neighbors of point must be retrieved, let these points be defined as where any neighbor . Then a centroid of the subset is calculated with the following equation:

Next we seek to produce an approximation of a plane by calculating two vectors and from the given subset of points. First, let be a k x 3 matrix built from the centroid being subtracted from each point in the nearest neighbor subset. To find the desired vectors we must perform a singular value decomposition (SVD), seen in the equation below, and notice that the covariance matrix can be diagonalized so that the eigenvectors of the covariance matrix are the columns of vector V (or the rows of vector ).

In general, the best r-rank approximation of an (n x n) matrix, , is found by diagonalizing the matrix as above, only keeping the first r columns of V (similarly only the first r rows of ), and only the first r diagonal elements of (or only first r rows and columns), assuming that the values on the diagonal of were in descending order. More precisely, for randomly ordered diagonal elements we keep only the maximum r many of them, along with their corresponding eigenvectors in matrix V. The reason for choosing the maximum valued eigenvalues is that it minimizes the amount of information lost in moving to a lower rank approximation matrix. Therefore, to produce the best approximation of a plane in we would take the two eigenvectors, and , of the covariance matrix (which are exactly the columns of V), with the highest corresponding eigenvalues. Those two eigenvectors span the plane we are looking for. Thus, the normal vector is simply the cross product of these eigenvectors: .

The reason for introducing the SVD is because in computing the covariance matrix we may lose some level of precision in the calculation. By simply factoring matrix A into its singular value decomposition and taking the cross product of the first two rows of , we can avoid this problem.

As previously mentioned, there are two viable normals that could be computed with this method, but only one normal is the desired normal. To solve this issue we could simply compute the vector from the camera position to point such that holds. If this does not hold then the vector can be flipped by changing the signs of its components. However, because there are likely to be many camera locations, say for all cameras of a given point , a point’s normal can be considered ambiguous if the following is true:

• There exists a such that

• There exists a such that

Such points cannot easily be oriented and thus additional computation is needed; fortunately, in most cases there are very few such normals. When these normals are discovered they are added to a queue of unfinished normals while the rest are placed in a list of correct normals. The algorithm iterates through the queue of ambiguous normals and tries to determine the orientation by looking at the neighboring points of . If the neighboring points of have already finished normals, then is oriented such that it is consistent with the neighboring normals by setting . If the neighboring points do not have already finished normals, then we move to the back of the queue, and continue until all normals are finalized.

This is copied from a section of my thesis. If you found this useful to your research please consider using the following bibtex:

@mastersthesis{CalebAdamsMSThesis,

author={Caleb Ashmore Adams},

title={High Performance Computation with Small Satellites and Small Satellite Swarms for 3D Reconstruction},

school={The University of Georgia},

url={http://piepieninja.github.io/research-papers/thesis.pdf},

year=2020,

month=may

}