[summary] Pixel2Mesh: Generating 3D Mesh Models from Single RGB Images (2018)

[arxiv, papers with code]

Summary

Approach

Pixel2Mesh is an end-to-end network, which takes an RGB 2D input image and produces a triangular 3D mesh by performing a few sequential mesh refinements applied to the initial ellipsoid mesh.

The initial mesh is an ellipsoid with fixed number of vertices (156), fixed axis radiuses (0.2m, 0.2m, 0.4m), and fixed relative location from the camera (0.8m). As a note, it is unclear from the work whether camera intrinsics are fixed across the training examples.

Throughout the paper, the mesh shape is considered to be a graph where mesh vertices are graph vertices, mesh edges are graph edges, and each vertex carries a feature vector in addition to the coordinates. These feature vectors are used in the graph convolution network described later.

Network architecture

• Input image processing is performed by VGG-16 convolutions, which produce feature maps used at the mesh refinement stages. Each mesh refinement stage except the very first one consists of a mesh deformation block and a mesh/graph unpooling layer.
• The mesh deformation block consists of two major parts: a perceptual feature pooling layer and a graph convolution network. It takes vertex coordinates C_i-1 and vertex features F_i-1 of the mesh as input and produces refined coordinates C_i and features F_i.
  
• The perceptual feature pooling block works by projecting the mesh onto the image plane by using known camera intrinsics, and matching projections of the mesh vertices C_i-1 with the feature maps produced by the 2D convolutions of the input image. Because the resolution of the mesh and the pooled feature maps do not match, bilinear interpolation is used. Essentially, for each mesh vertex this process extracts a vector—a perceptual feature—from the 2D feature maps.
• The graph convolution network takes vertex features F_i-1 concatenated with extracted perceptual features, performs a series of graph convolutions and produces updated vertex coordinates and features.
• To better match the ground truth, the resolution of the mesh shape is increased by the graph unpooling layer. For each edge, this layer creates a new vertex splitting this edge in half. Afterwards, the newly created vertices are connected, which splits each face into 4 smaller faces.
  

Losses

To train the network, a combination of four different losses is used: the Chamfer loss, a normal loss, a laplacian regularization, and an edge length regularization. These losses are balanced with some manually selected coefficients.

• The Chamfer loss measures the distance of each point to the closest point in the other point set, and essentially ensures that the produced mesh more or less matches the ground truth:
  
• The normal loss forces the edges of a particular vertex to be perpendicular to the surface normal in the closest corresponding ground truth vertex:
  
• To ensure that the mesh deformation is not too aggressive (which might lead to e.g. mesh self-intersection), the laplacian regularization is used. First, a laplacian coordinate is computed for each vertex:
  After that, the laplacian regularization is defined as an L2 difference of laplacian coordinates before and after a deformation block:
  
• Finally, to penalize flying vertices, the edge length regularization is used:
  

Experiments

• Some qualitative results:
  
• Ablation study examples: it is easy to see how the edge length regularization or the normal loss help to produce smoother shapes:
  

Metrics

• Comparison against 3D-R2N2, PSG, and N3MR using the F-score metric on the ShapeNet dataset. Precision and recall used by the F-score are calculated by computing the fraction of mesh vertices which have a corresponding ground truth vertex within a certain radius τ.
• Same comparison using the Chamfer distance (CD) and the earth mover's distance (EMD).
  

Discussion

• VGG-16 architecture progressively decreases the input image resolution in the later stages where the mesh finetuning happens. Could switching to a UNet-like architecture be better at preserving the details?
• Perceptual feature pooling does not take into account that some mesh vertices might be occluded from the camera and therefore should not have corresponding pixels in the 2D feature maps.
• It seems that the produced 3D mesh will always be homotopic to a sphere, so there is no way to handle non-contiguous shapes.

Used diagrams are taken from the paper with minor changes.
All errors present in the interpretation are my own.