1. Summary

Published in TVCG2021 Periodical
Code ：http://github.com/dongbo-BUAA-VR/Pointfilter
It basically uses the thinking of bilateral filtering

2. motivation

Learn the displacement vector , Denoised points = noise + Displacement vector
So the essential processing is to calculate The displacement vector here .

3. Method

Preprocessing ：

Given a set of point clouds Real block $P$ And noise block $\hat{P}$,$r$ It's a block radius , Generally, it is the diagonal of the bounding box 5%

$P$: Clean point cloud
$N$: noise

Once the block is generated , Two problems need to be considered in point cloud filtering ：

1. How to avoid Unnecessary degrees of freedom in the observation domain ？
2. How to protect Pointfilter Sensitive to some geometric transformations ？

about 1, You can transform the block to the origin （ With $\widehat{p_i}$ Centered ）, And make a telescopic transformation

In order to ensure the invariance of rigid body , Use PAC alignment , First of all Z Axis , then X Axis .
For the convenience of parameter adjustment , The default input is fast $|{\hat{P}}_i|=500$, The number of blocks is less than 500 Then fill , If it is greater than, conduct down sampling .

The overall framework ：

According to the adjacent structure Project each noise onto the foundation surface , Therefore, the codec network is designed ：

Encoder Encoder

Input ：PCA Processed point cloud
Purpose ： Or features represent information
Content ：

1. feature extraction ： use MLP Realization , Different scale feature extraction
2. Collector： In fact, that is max-pooling operation , Turn the feature into a 1024 Dimension characteristics .
   The whole is basically PointNet+Batch Norm, Ensure that the characteristics of each layer are standard distribution .

The code description ：

class pointfilter_decoder(nn.Module):
    def __init__(self):
        super(pointfilter_decoder, self).__init__()

        self.fc1 = nn.Linear(1024, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 3)

        self.bn1 = nn.BatchNorm1d(512)
        self.bn2 = nn.BatchNorm1d(256)

        self.dropout_1 = nn.Dropout(0.3)
        self.dropout_2 = nn.Dropout(0.3)

    def forward(self, x):
        x = F.relu(self.bn1(self.fc1(x)))
        # x = self.dropout_1(x)
        x = F.relu(self.bn2(self.fc2(x)))
        # x = self.dropout_2(x)
        x = torch.tanh(self.fc3(x))
        return x

Decoder decoder

The decoder is directly FCN, Then convert to the coordinate domain .
Here we need to pay attention to , What we learned is the part of denoising , So the formula 7 $r{\mathbf{R}}^{-1}f(.)$ This term is a displacement vector .

As shown in the figure , In fact, it's here $n_i$

The code description ：

class pointfilter_decoder(nn.Module):
    def __init__(self):
        super(pointfilter_decoder, self).__init__()

        self.fc1 = nn.Linear(1024, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 3)

        self.bn1 = nn.BatchNorm1d(512)
        self.bn2 = nn.BatchNorm1d(256)

        self.dropout_1 = nn.Dropout(0.3)
        self.dropout_2 = nn.Dropout(0.3)

    def forward(self, x):
        x = F.relu(self.bn1(self.fc1(x)))
        # x = self.dropout_1(x)
        x = F.relu(self.bn2(self.fc2(x)))
        # x = self.dropout_2(x)
        x = torch.tanh(self.fc3(x))

        return x

Loss function

There are two kinds of ： Projection loss $L_{proj}^a$ + Loss of similarity $L_{rep}$
Using the aggregation of exclusion penalty terms , The total loss is as follows 5 Shown . among $\eta =0.97$

Projection loss ： The formula 3

Gauss function ： The formula 4

$diag$ The size is $P_i$ The diagonal length of the bounding box ,$m=|{\hat{P}}_i|$, The default angle is supported 15 degree .$\mathbf{n}$ Is the normal vector .

analysis

Combined with the traditional denoising method loss, Compact expression ; But it is not very good to retain sharp noise .

4. experiment