R. Falque

Half Edge Data Structure

2020-03-13T00:00:00+00:00

TL;DR: Definition of a half-edge data structure in cuda.

Info! Unfinished notes

I am a big fan of simple data structures like the ones used in libIGL (a N by 3 matrix of doubles for vertices and a M by 3 matrix of integers for faces). However, these data structures can not be used for efficient circulation through the faces (e.g., finding the neighbouring faces of a face is hard).

An alternative is to embrace a more complexe data structure that is more complex to define and use more memory for storing but does provide more flexibility to travel through the mesh. Amongst the popular data structures, halfedges structures are memory efficient but also offer powerful ways to travel on a mesh.

Half-Edge data structures definition

From the documentation of OpenMesh.

Each vertex references one outgoing halfedge, i.e. a halfedge that starts at this vertex (1).
Each face references one of the halfedges bounding it (2).
Each halfedge provides a handle to
- the vertex it points to (3),
- the face it belongs to (4)
- the next halfedge inside the face (ordered counter-clockwise) (5),
- the opposite halfedge (6),
- (optionally: the previous halfedge in the face (7)).

Eigen Rows Versus Cols

2020-02-03T00:00:00+00:00

TL;DR: The use of a Eigen::Matrix3Xd or Eigen::Matrix3Xf should be prefered to store 3D pointclouds in 3D libraries.

In C++, Eigen matrices are one of the most common object used to store the raw information of 3D objects. This is the case for both libIGL and cilantro. However, this two libraries are using two different coordinates to store the information, e.g., in libIGL, vertices would be stored in a N by 3 matrix and Cilantro would store it into a 3 by N matrix. While this question might seems insignificant, we will show why it matter and which one should you use?

It is more logical given the standard Eigen structures

While as shown in the libIGL documentation, the use of a N by 3 matrix seems more readable, it creates few problems. However, the natural structure to store a 3D point would be Eigen::Vector3d which is actually defined as a Eigen::Matrix <double , 3, 1> in the background. Therefore, it seems natural to stores points using a Eigen::Matrix <double , 3, Eigen::Dynamic>.

It is a natural fit for the geometry module

An additional tool build into the Eigen library is the geometry module which allows to apply transformations to a set of 3D points. For instance applying an affine transformations to a 3 by N matrix would be performed as follow:

Eigen::Affine3d transform
Eigen::Matrix3Xd vertices, transformed_vertices;
transformed_vertices = transform * vertices;

While using the format defined in libIGL would be writen like:

Eigen::Affine3d transform
Eigen::MatrixX3d vertices, transformed_vertices;
transformed_vertices = (transform * vertices.transpose() ).transpose();

It is safer

One problem that might occur in constantly using .transpose() is that the users might:

Eigen::Affine3d transform
Eigen::MatrixXd vertices, transformed_vertices;
vertices = vertices.transpose();
transformed_vertices = transform * vertices;
transformed_vertices = transformed_vertices.transpose();

Which should actually happen through .transposeInPlace() to avoid an aliasing problem.

Point_cloud_skeletonization

2019-09-12T00:00:00+00:00

This are my personal notes on skeletonization methods.

Point cloud contraction

Functional Maps

2019-07-31T00:00:00+00:00

Serie of personal notes on functional maps

Info! Unfinished notes

List of related ressources:

SIGGRAPH 2017 course
AIM@shape (3D models repository)

Spectral decomposition

``Can you hear the shape of a drum?’’ M. Kac, 1966. No … but …

Eigenfunction decomposition

Let us first consider the following shape which is defined as a triangular mesh with $m$ vertices.

The eigenfunctions of the Laplace-Beltrami operator are obtained by solving:

$\Delta_s \phi_i = \lambda_i \phi_i,$

where $\Delta_s$ is the Laplace-Beltrami operator¹, $\phi_i$ is the $i^{th}$ eigenfunction and $\lambda_i$ its associated eigenvalues. In practice, we deal with discrete formulations and the $\Delta_s$ is a square matrix noted $L$ (of size $m \times m$ for the source) and the eigenfunctions are represented as eigenvectors $\Phi$ (e.g., a vector of length $m$). This gives us the following formulation: \begin{equation} L \Phi_i = \lambda_i \Phi_i, \label{eq:eigenfunction_decomposition} \end{equation}

Equation \eqref{eq:eigenfunction_decomposition} is then typically solved on a sparse matrix eigensolver and the eigenvectors are then sorted based on the order of the eigenvalues.

What do these eigenfunctions means?

It is possible to visualize the eigenfunctions projected onto the geometries:

As shown on the figure, after being sorted according to the eigenvalues, the eigenfunctions of the LB operators are ordered from low to high frequencies. This property can be used to apply a low pass filter on the shape. For exemple, we can reconstruct a shape with different number of eigenfunctions²: First, we project the geometry onto each eigenfunction such as:

$\alpha^x_i \leftarrow \sum_{j=1}^m x_j \Phi_i(j),~~~~~~ \alpha^y_i \leftarrow \sum_{j=1}^m y_j \Phi_i(j),~~~\text{and}~~~ \alpha^z_i \leftarrow \sum_{j=1}^m z_j \Phi_i(j)$

And the surface reconstruction for $k$ eigenvalues is obtained by:

$x_j \leftarrow \sum_{i=1}^{k} \alpha_i^x \Phi_i(j),~~~~~~ y_j \leftarrow \sum_{i=1}^{k} \alpha_i^y \Phi_i(j),~~~\text{and}~~~ z_j \leftarrow \sum_{i=1}^{k} \alpha_i^z \Phi_i(j)$

The final reconstruction with different number of eigenfunction:

Can we do more?

Now given a second shape with $n$ vertices, and its own decomposition formulated similarly such as:

$\beta^x_i \leftarrow \sum_{j=1}^n x_j' \Phi_i'(j),~~~~~~\beta^y_i \leftarrow \sum_{j=1}^n y_j' \Phi_i'(j),~~~\text{and}~~~\beta^z_i \leftarrow \sum_{j=1}^n z_j' \Phi_i'(j)$

Levy² mention pose transfert as a potential application ``provided that the $\alpha$’s and the $\beta$’s are expressed in the same langage’’. In this context, the definition of the reconstruction is defined as:

$x_j \leftarrow \sum_{i=1}^{l} \alpha_i^x \Phi_i'(j) + \sum_{i=l+1}^{k} \beta_i^x \Phi_i'(j)\\ y_j \leftarrow \sum_{i=1}^{l} \alpha_i^y \Phi_i'(j) + \sum_{i=l+1}^{k} \beta_i^y \Phi_i'(j)\\ z_j \leftarrow \sum_{i=1}^{l} \alpha_i^z \Phi_i'(j) + \sum_{i=l+1}^{k} \beta_i^z \Phi_i'(j)$

Let’s give it a try by using the 5 first coefficients ($l = 5$) from the cow and apply to a bull:

Why did it fail?

As Levy says in his paper the $\alpha$’s and the $\beta$’s have to be expressed in the same language. Let’s look at the first eigenfunctions to see how they are distributed:

As shown on the figure, some of the eigenfunctions seems to have a good correspondence and some of them are mixted, in other worlds they do not speak the same language. More specifically I hand picked some of the eigenfunctions that have interesing properties in the following figure:

Both $2^{nd}$, $4^{th}$, $5^{th}$, and $10^{th}$ eigenfunctions are a good match. The eigenfunctions 4 (on the bull) and 3 (on the cow) have a good correspondence but are not ordered similarly. Eigenfunctions 8 (on the bull) and 7 (on the cow) are the opposite of each other; this is a well known phenomenon as the eigenfunction decomposition is prone to sign flipping.

As a conclusion, we can consider that the pose transfert did not work because the eigenfunctions do not speak the same language.

Functional maps

Preliminaries and notations

Let consider the matching between two shapes: the source $M$ and the target $N$.

Both the source and the target are defined as a triangular meshes with $m$ and $n$ vertices respectively.

Feature descriptors

Wave Kernel Signature

Heat Kernel Signature

SHOT

See ³

Functional map computation

Features matching

The feature matching is obtained by finding the map which maximize the similarity between the descriptors projected on the eigenfunctions. In other words, we seek to minimize: \begin{equation} C = \arg\min_C \vert\vert CA-B \vert\vert^2 \end{equation}

Regularization terms

The map will be isometric if and only if: \begin{equation} C \Delta_M = \Delta_N C \end{equation}

The mapping will be locally volume preserving if and only if the map is orthonormal which is defined as: \begin{equation} C^T C = Id \end{equation}

The mapping is conformal if and only if: \begin{equation} C^T \Delta_1 C= \Delta_2 \end{equation}

Final cost function

The final functional map that include the feature matching and the regularization term is defined as: \begin{equation} C_{opt} = \arg\min_C \vert\vert CA-B \vert\vert^2 + \vert\vert C \Delta_M - \Delta_N C \vert\vert^2 \end{equation}

References

M. Meyer, M. Desbrun, P. Schroder, and A. H. Barr, Discrete Differential-Geometry Operators for Triangulated 2-Manifolds, Springer, 2003. ↩
B Levy, Laplace-Beltrami Eigenfunctions Towards an Algorithm That “Understands” Geometry, SMI, 2006 ↩ ↩²
, F. Tombari, S. Salti, and L. D. Stefano Unique Signatures of Histograms for Local Surface Description, ECCV, 2010. ↩

Closed Mesh Volume Computation

2019-07-27T00:00:00+00:00

Volume and surface area computation for triangle meshes.

Warning! This method works only for watertight meshes.

Volume computation

Using the notations defined in the following figure: Figure 1: volume of a tetrahedron

The surface area of the face $ABC$ can be computed as \begin{equation} Area(ABC) = \frac{ \vert \vec{AB} \times \vec{AC} \vert } {2} \end{equation}

Let us now consider the volume of a tetrahedron by adding a point $O$ (e.g., $O = \{0,0,0\}$ ). The volume of $OABC$ is then defined as: \begin{equation} Volume(OABC) = \frac{1}{3} . \frac{ \vert \vec{AB} \times \vec{AC} \vert } {2}. \vert \vec{OG}.\vec{N} \vert, \end{equation} with $\vert \vec{OG}.\vec{N} \vert$ the height of the tetrahedron.

The final volume is obtained by integrating the volume of the tetrahedron defined for each face. However, not all tetrahedron should be added. This idea is illustrated for a 2D case in the following figure:

The areas in blue should be added, and the areas in red should be removed during the integration. This is performed by considering the sign of the dot product between $\vec{OG}$ and the normal of the face $\vec{N}$ (in practice, we simply remove the norm used above). The final formula of the volume integration is: \begin{equation} Volume = \sum_{f \in F} \frac{1}{3} . \frac{ \vert \vec{AB} \times \vec{AC} \vert } {2}. (\vec{OG} . \vec{N}) \end{equation}

Similarly, the surface area of the mesh can be obtained with: \begin{equation} Area = \sum_{f \in F} \frac{ \vert \vec{AB} \times \vec{AC} \vert } {2} \end{equation}

Info! Any points O can be used for the computation of the volume.

Validation

Example of volume computed on the following dataset

Tables	computed value	real value	relative error
volume cube	$64.174 m^3$	$64.0 m^3$	$0.0027$
surface area cube	$90.652 m^2$	$96.0 m^2$	$0.0557$
volume cylinder	$12.536 m^3$	$12.566 m^3$	$0.0024$
surface area cylinder	$30.981 m^2$	$31.416 m^2$	$0.0138$

Info! The error actually comes from the Poisson surface reconstruction.

Data

The data and the code is available here (in C++ with PCL as a dependency), we start from a point cloud with the surface reconstructed using Poisson surface reconstruction¹.


cube.ply	cylinder.ply	volume_code.zip

References

M. Kazhdan, M. Bolitho, and H. Hoppe, Poisson surface reconstruction, In SGP ’06: Proceedings of the fourth Eurographics symposium on Geometry processing. ↩

Discrete Differential Geometry

2019-07-25T00:00:00+00:00

Serie of notes on discrete differential-geometry.

Info! Unfinished notes

Content

discrete differential operators
definition of the operator with the vertex as a reference
implementation with respect to the one-ring neighbourhood

List of ressources:

Discrete differential-geometry operators

Gradient

\begin{equation} \nabla f = \big( \frac{\partial f}{\partial x}, \frac{\partial f}{\partial y}, \frac{\partial f}{\partial z} \big) \notag \end{equation}

$\nabla f(x) = (f_j - f_i) \frac{(x_i-x_k)^\bot}{2A_T} + (f_k - f_i) \frac{(x_j-x_i)^{\bot}} {2A_T}$

Divergent

$\nabla . f = \frac{\partial f_x}{\partial x} + \frac{\partial f_y}{\partial y} + \frac{\partial f_z}{\partial z}$

Curl

Laplace-Beltrami operator

The Laplace operator is defined in the Euclidean space as: \begin{equation} \Delta f = \nabla \cdot \nabla .f = \frac{\partial^2 f}{\partial x^2} + \frac{\partial^2 f}{\partial y^2} + \frac{\partial^2 f}{\partial z^2}. \end{equation}

The Laplace-Beltrami operator, noted $\Delta_s$ , generalizes the Laplacian to surfaces (i.e., 2D manifolds) and is defined with respect to the curvature.

Relation with curvature: Let’s first define the curvatures on continuous surfaces before to formulate it into discrete surfaces, following the notations from Meyer et al.¹.

Given a surface $S$, a point $p$, its associated normal vector $\mathbf{n}$, and a unit vector $\mathbf{e}_\theta$; the notion of normal curvature $\kappa^N(\theta)$ is locally defined as the quantification of the curvature in the plane $\{p, \mathbf{n}, \mathbf{e}_\theta \}$ . The two principal curvatures $\kappa_1$ and $\kappa_2$ and the associated orthogonal directions $\mathbf{e}_1$ and $\mathbf{e}_2$ are the extremum values of the normal curvature. The mean curvature $\kappa_H$ is defined as \begin{equation} \kappa_H = \frac{1}{2\pi}\int^{2\pi}_0\kappa^N(\theta)d\theta, \end{equation} which can be simplified using the principal curvatures as $\kappa_H = \dfrac{\kappa_1 + \kappa_2}{2}$. Additionally, the Gaussian curvature $\kappa_G$ is defined as $\kappa_G = \kappa_1\kappa_2$.

The Laplace-Beltrami operator $\mathbf{L}(p)$ is defined as $\mathbf{L}(p) = 2\kappa_H(p)\mathbf{n}(p)$. The integration of the Laplace-Beltrami operator is then defined as

\begin{equation} \int\int_{A}\mathbf{L}(\mathbf{x})d(A) = \frac{1}{2}\sum_{j\in N(i)}(\cot{\alpha_{ij}} + \cot{\beta_{ij}})(\mathbf{x}_i - \mathbf{x}_j). \label{eq:Laplacian_integration} \end{equation}

Let us now consider a vertex and it’s own one ring neighbourhood defined as follow:

A more practical Laplace-Beltrami Operator implementation is to store the right hand side of equation \eqref{eq:Laplacian_integration} under a $n \times n$ sparse matrix form $\mathbf{L}$ where each elements is the vertex to vertex relationship such as:

$\boldsymbol{L}_{ij} = \begin{cases} \frac{1}{2}\sum_{i\neq j} \cot \alpha_{ij} + \cot \beta_{ij} & \text{if } i = j,\\ -\frac{1}{2} \cot \alpha_{ij} + \cot \beta_{ij} & j \in \mathcal{N}(i),\\ 0 & j \notin \mathcal{N}(i). \end{cases}$

With a one ring neighbourhood defined as follow:

The C++ pseudo-code of that cotangent Laplacian (for a sparse matrix):

for(int i : vertices)
{
  for(int j : one_ring(i))
  {
    for(int k : triangle_on_edge(i,j))
    {
      L(i,j) = cot(angle(i,j,k));
      L(i,i) -= cot(angle(i,j,k));
    }
  }
}

In practice more efficient implementation can be used, see libigl implementation for more details.

Mass matrix

Warning! This formula is easy to compute but is slightly wrong for obtuse triangles (angles $> 90^\circ$).

The mass matrix defined here is the area of the polygon where each point is the barycenter of each triangle (barycentric cells). The are computed is the part filled in blue in the following figure:

With A, an $n$ by $n$ diagonal matrix:

for(int i : vertices)
{
  for(int j : one_ring(i))
  {
    for(int k : triangle_on_edge(i,j))
    {
      area = (j-i).cross(k-i).norm() / 2;   // get area of the face
      local_area = area / 3;                // get the are towards the barycenter
      A(i, i) += local_area / 2;                  // / 2 because added twice
    }
  }
}

References

M. Meyer, M. Desbrun, P. Schroder, and A. H. Barr, Discrete Differential-Geometry Operators for Triangulated 2-Manifolds, Springer, 2003. ↩

Geodesic In Heat For Pointcloud

2019-07-25T00:00:00+00:00

Description of the geodesic in heat method applied on a point cloud.

Info! Unfinished notes

Propagation of heat

Let’s consider the propagation of the heat generated by a source located at the point $x$ over a point cloud. At the time $t$ , the temperature at the point $y$ can be obtained using the heat kernel

$k_{t,x}(y).$

The Varadhan’s formula¹ states that the geodesic distance $\phi$ between any pair of points $x, y$ can be obtained by

$\phi(x,y) = \lim_{t\rightarrow 0} \sqrt{-4t\log k_{t,x} (y)}.$

Estimating the distance with this method can be inaccurate as it is hard to evaluate $k_{t,x} (y)$ and Crane et. al² proposed to use the gradient of the heat as a better approximation.

The heat method

The heat method is performed in three steps:

$X = - \nabla u~/~\vert\nabla u\vert$ ,
$\Delta \phi = \nabla \cdot X$ .

The heat method on a point cloud

Estimation of the gradient with Weighted Least Squares from A. Nealen³.

References

S. R. S. Varadhan, On the behavior of the fundamental solution of the heat equation with variable coefficients, Communications on pure and applied mathematics, 1967. ↩
K. Crane and C. Weischedel, and M. Wardetzky, Geodesics in Heat:A New Approach to Computing Distance Based on Heat Flow, ACM, 2013. ↩
A. Nealen, An As-Short-As-Possible Introduction to the Least Squares, Weighted LeastSquares and Moving Least Squares Methods for Scattered DataApproximation and Interpolation, 2004 ↩

Simple C++ Graph Library

2019-06-15T00:00:00+00:00

We provide a simple and light graph library for visualizing and analyzing graph structures. The library builds upon Libigl, following its design principle and adapt it for graphs. The graphs are stored as .obj files (not all other formats support edges) which can be easily edited in Blender.

The repository hosting the code is available here: https://github.com/rFalque/libGraphCpp

Installation:

Install libigl and Eigen which are dependencies. Depending on how Libigl has been installed, you might need to update the location of the library in the src/cmake/FindLIBIGL.cmake file.

Then simply type the following commands in the command line:

To build the library and the example

mkdir build
cd build
cmake ../src
make

to build and run the tests:

mkdir build_tests
cd build_tests
cmake ../src/tests
make

Features:

graph instanciation from Eigen matrices (‘Eigen::MatrixXd’ for nodes position and ‘Eigen::MatrixXi’ for edges definition)
graph visualization (using libigl and few headers from directional)
removing nodes
connectivity (linear time)
biconnectivity (linear time)
triconnectivity (quadratic time)
bridges detection (linear time)
shortest path on the graph

Features to add:

graph augmentation
add nodes

Design principles:

header only library
simple structures for storing the graph (Eigen::Matrix) and adjacency lists (std::vector)
easy to modify

Graph visualization:

Graph editing:

Open Blender and start creating a graph. A mesh can be easily transformed into a graph by deleting the faces only (change to edit mode, select everything a, open the delete menu del, pick Only faces).

Other alternatives:

OGDF: (C++) self-contained class library for the automatic layout of diagrams. OGDF offers sophisticated algorithms and data structures to use within your own applications or scientific projects (including triconnectivity tests in linear time with SPQR decomposition)
BOOST: (more?) efficient implementation
Matlab graph class: sweet one

Welcome to Jekyll!

2019-06-14T01:49:06+00:00

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.

post options:

hidden: true
published: false

R. Falque

Half Edge Data Structure

links

Half-Edge data structures definition

Eigen Rows Versus Cols

It is more logical given the standard Eigen structures

It is a natural fit for the geometry module

It is safer

Point_cloud_skeletonization

Point cloud contraction

Functional Maps

Spectral decomposition

Eigenfunction decomposition

What do these eigenfunctions means?

Can we do more?

Why did it fail?

Functional maps

Preliminaries and notations

Feature descriptors

Wave Kernel Signature

Heat Kernel Signature

SHOT

Functional map computation

Features matching

Regularization terms

Final cost function

References

Closed Mesh Volume Computation

Volume computation

Validation

Data

References

Discrete Differential Geometry

Content

Discrete differential-geometry operators

Gradient

Divergent

Curl

Laplace-Beltrami operator

Mass matrix

References

Geodesic In Heat For Pointcloud

Propagation of heat

The heat method

The heat method on a point cloud

References

Simple C++ Graph Library

Installation:

Features:

Features to add:

Design principles:

Graph visualization:

Graph editing:

Other alternatives:

Welcome to Jekyll!

HTML / CSS Links: