2、PF-Net点云补全

2、PF-Net 点云补全

PF-Net论文链接：PF-Net

PF-Net （Point Fractal Network for 3D Point Cloud Completion）是一种专门为三维点云补全设计的深度学习模型。点云补全实际上和图片补全是一个逻辑，都是采用GAN模型的思想来进行补全，在图片补全中，将部分像素点删除并且标记，然后卷积特征提取预测、判别器判别，来训练模型，生成的像素点与原来像素点比较完成模型的训练。而PF-Net就是采用GAN的思想在3D点云上的应用。

模型架构

Multi-Resolution Encoder(MRE)： 编码器，PF-Net在特征提取方面，在PointNet的基础上进行了改进，在不同层面进行采样，但是与PointNet++的多层面采样不一样，PF-Net没有像PointNet++一样提取某个点周围的点的特征，进行分组提取特征，而是采用最远距离采样，选取不同个个数的采样点，从细节到轮廓多层次采样,其次在进行卷积时，对于PointNet只在最后一层进行maxpooling来获得最终特征值，但是PF-Net则在提取的过程中，在卷积提取过程中，对卷积结果进行maxpooling提取特征，最终将多次maxpooling提取到的特征拼接，使特征既有轮廓信息，又有细节信息。

Point Pyramid Deconder(PPD)： 解码器，在进行预测时，先是预测出一个轮廓，再将轮廓信息加入到下面，逐级预测更多的细节，慢慢加入特征，使预测更急准确。

Discriminator： 判別器，与GAN中的判别器逻辑一模一样，有两组输入，对比是否预测准确，实际上就是做了一个二分类，输出每个点结果为True或False，表示预测是否正确。

对于训练参数的更新，主要CD和判别器的Loss，CD计算的是每个预测点和距离他最近的正确点的距离，同时正确的点也会和预测点计算CD值，获得Loss值，更新参数。

模型架构图

数据准备

for i, data in enumerate(dataloader, 0): 
    real_point, target = data  # 从dataloader中获取真实的点云数据和对应的目标标签
    
    batch_size = real_point.size()[0]  # 获取批量大小
    real_center = torch.FloatTensor(batch_size, 1, opt.crop_point_num, 3)  # 初始化用于存储被裁剪的点
    print(real_center.shape)  # 输出 real_center 的形状
    input_cropped1 = torch.FloatTensor(batch_size, opt.pnum, 3)  # 初始化裁剪后的输入点云数据
    print(input_cropped1.shape)  # 输出 input_cropped1 的形状 ([4, 2048, 3])
    
    # 将 real_point 复制到 input_cropped1 中
    input_cropped1 = input_cropped1.data.copy_(real_point)
    print(input_cropped1.shape)  # 输出复制后的 input_cropped1 的形状 ([4, 2048, 3])
    
    # 添加一个维度到 real_point，方便之后的操作
    real_point = torch.unsqueeze(real_point, 1)
    print(real_point.shape)  # 输出添加维度后的形状 ([4, 1, 2048, 3])
    
    # 添加一个维度到 input_cropped1，方便之后的操作
    input_cropped1 = torch.unsqueeze(input_cropped1,1)
    print(input_cropped1.shape)  # 输出添加维度后的 input_cropped1 的形状

    p_origin = [0,0,0]  # 设置原点位置
    
    # 根据不同的裁剪方法裁剪点云
    if opt.cropmethod == 'random_center':
        # 设置随机视角的选项
        choice = [torch.Tensor([1,0,0]), torch.Tensor([0,0,1]), torch.Tensor([1,0,1]), torch.Tensor([-1,0,0]), torch.Tensor([-1,1,0])]
        for m in range(batch_size):
            # 从选择中随机选取一个视角
            index = random.sample(choice,1)
            distance_list = []
            p_center = index[0]  # 选取的视角作为中心点
            for n in range(opt.pnum):
                # 计算每个点与中心点之间的距离
                distance_list.append(distance_squre(real_point[m,0,n], p_center))
            
            # 将距离排序，得到每个点的索引和值
            distance_order = sorted(enumerate(distance_list), key=lambda x: x[1])
            print(distance_order)  # 输出距离排序
            
            # 裁剪掉距离中心点最近的 opt.crop_point_num 个点
            for sp in range(opt.crop_point_num):
                input_cropped1.data[m, 0, distance_order[sp][0]] = torch.FloatTensor([0,0,0])  # 用 [0,0,0] 替换裁剪掉的点
                real_center.data[m, 0, sp] = real_point[m, 0, distance_order[sp][0]]  # 保存被裁剪的点到 real_center 中

    # 重新调整标签的大小并赋值
    label.resize_([batch_size, 1]).fill_(real_label)
    print(label.shape)  # 输出标签的形状

    # 将数据移到 GPU 设备上
    real_point = real_point.to(device)
    real_center = real_center.to(device)
    input_cropped1 = input_cropped1.to(device)
    label = label.to(device)

    ############################
    # (1) 准备数据
    ############################
    
    # 将 real_center 设置为可求导变量
    real_center = Variable(real_center, requires_grad=True)
    real_center = torch.squeeze(real_center, 1)  # 去除多余的维度
    
    # 通过最远点采样算法从 real_center 中选取64个关键点
    real_center_key1_idx = utils.farthest_point_sample(real_center, 64, RAN=False)
    real_center_key1 = utils.index_points(real_center, real_center_key1_idx)
    real_center_key1 = Variable(real_center_key1, requires_grad=True)  # 设置为可求导变量
    print(real_center_key1.shape)  # 输出关键点的形状

    # 通过随机最远点采样算法从 real_center 中选取128个关键点
    real_center_key2_idx = utils.farthest_point_sample(real_center, 128, RAN=True)
    real_center_key2 = utils.index_points(real_center, real_center_key2_idx)
    real_center_key2 = Variable(real_center_key2, requires_grad=True)  # 设置为可求导变量
    print(real_center_key2.shape)  # 输出关键点的形状

    # 去除 input_cropped1 的多余维度
    input_cropped1 = torch.squeeze(input_cropped1, 1)
    print(input_cropped1.shape)  # 输出去除维度后的形状

    # 从 input_cropped1 中采样不同数量的点
    input_cropped2_idx = utils.farthest_point_sample(input_cropped1, opt.point_scales_list[1], RAN=True)
    input_cropped2 = utils.index_points(input_cropped1, input_cropped2_idx)
    
    input_cropped3_idx = utils.farthest_point_sample(input_cropped1, opt.point_scales_list[2], RAN=False)
    input_cropped3 = utils.index_points(input_cropped1, input_cropped3_idx)
    
    # 将裁剪后的点云设置为可求导变量
    input_cropped1 = Variable(input_cropped1, requires_grad=True)
    print(input_cropped1.shape)  # 输出裁剪后的 input_cropped1 形状
    
    input_cropped2 = Variable(input_cropped2, requires_grad=True)
    print(input_cropped2.shape)  # 输出裁剪后的 input_cropped2 形状
    
    input_cropped3 = Variable(input_cropped3, requires_grad=True)
    print(input_cropped3.shape)  # 输出裁剪后的 input_cropped3 形状
    
    # 将裁剪后的数据移到 GPU 设备上
    input_cropped2 = input_cropped2.to(device)
    input_cropped3 = input_cropped3.to(device)

    # 将不同尺度的裁剪数据保存到列表中
    input_cropped = [input_cropped1, input_cropped2, input_cropped3]

Multi-Resolution Encoder(MRE)

**Multi-Resolution Encoder(MRE)：**编码器，PF-Net在特征提取方面，在PointNet的基础上进行了改进，在不同层面进行采样，但是与PointNet++的多层面采样不一样，PF-Net没有像PointNet++一样提取某个点周围的点的特征，进行分组提取特征，而是采用最远距离采样，选取不同个个数的采样点，从细节到轮廓多层次采样,其次在进行卷积时，对于PointNet只在最后一层进行maxpooling来获得最终特征值，但是PF-Net则在提取的过程中，在卷积提取过程中，对卷积结果进行maxpooling提取特征，最终将多次maxpooling提取到的特征拼接，使特征既有轮廓信息，又有细节信息。

class Latentfeature(nn.Module):
    # ..
    def forward(self, x):
        outs = []  # 用于存储各层的输出结果
        print(x[0].shape)  # 打印输入数据第一个尺度的形状

        # 对第一个尺度的数据进行卷积处理，并将结果存入 outs 列表
        for i in range(self.each_scales_size):
            outs.append(self.Convlayers1[i](x[0]))

        # 对第二个尺度的数据进行卷积处理，并将结果存入 outs 列表
        for j in range(self.each_scales_size):
            outs.append(self.Convlayers2[j](x[1]))

        # 对第三个尺度的数据进行卷积处理，并将结果存入 outs 列表
        for k in range(self.each_scales_size):
            outs.append(self.Convlayers3[k](x[2]))

        # 将不同尺度的卷积输出在维度2上拼接起来，得到拼接后的特征
        latentfeature = torch.cat(outs, 2)

        # 将拼接后的特征进行转置操作，交换维度1和维度2
        latentfeature = latentfeature.transpose(1, 2)

        # 通过卷积层和批归一化层，对拼接特征进行卷积和激活处理
        latentfeature = F.relu(self.bn1(self.conv1(latentfeature)))

        # 压缩特征图的一个维度，将其从 (batch_size, 1, ...) 变为 (batch_size, ...)
        latentfeature = torch.squeeze(latentfeature, 1)

        return latentfeature  # 返回最终的特征图

# 来源 self.Convlayers1[i](x[0])
class Convlayer(nn.Module):
	# ..
    def forward(self, x):
        x = torch.unsqueeze(x, 1)  # 在输入的维度上增加一个维度，转换为 (batch_size, 1, point_num, 3)

        # 通过第一层卷积+批归一化+ReLU激活
        x = F.relu(self.bn1(self.conv1(x)))

        # 通过第二层卷积+批归一化+ReLU激活
        x = F.relu(self.bn2(self.conv2(x)))

        # 通过第三层卷积，提取128通道的特征
        x_128 = F.relu(self.bn3(self.conv3(x)))

        # 通过第四层卷积，提取256通道的特征
        x_256 = F.relu(self.bn4(self.conv4(x_128)))

        # 通过第五层卷积，提取512通道的特征
        x_512 = F.relu(self.bn5(self.conv5(x_256)))

        # 通过第六层卷积，提取1024通道的特征
        x_1024 = F.relu(self.bn6(self.conv6(x_512)))

        # 使用最大池化层对 x_128 进行池化，去除掉特征图的某一维度
        x_128 = torch.squeeze(self.maxpool(x_128), 2)

        # 对其他特征图 x_256, x_512, x_1024 同样进行池化操作
        x_256 = torch.squeeze(self.maxpool(x_256), 2)
        x_512 = torch.squeeze(self.maxpool(x_512), 2)
        x_1024 = torch.squeeze(self.maxpool(x_1024), 2)

        # 将各层的特征图按通道拼接
        L = [x_1024, x_512, x_256, x_128]
        x = torch.cat(L, 1)  # 将四层特征拼接在一起

        return x  # 返回最终特征

这样的过程会进行三次，对于不同采样点个数都进行处理

Point Pyramid Deconder(PPD)

解码器，在进行预测时，先是预测出一个轮廓，再将轮廓信息加入到下面，逐级预测更多的细节，慢慢加入特征，使预测更急准确。

class _netG(nn.Module):
    def forward(self, x):
        # 获取输入特征
        x = self.latentfeature(x)

        # 通过全连接层并激活处理，逐步缩小特征维度
        x_1 = F.relu(self.fc1(x))  # 1024维度的特征处理
        x_2 = F.relu(self.fc2(x_1))  # 512维度的特征处理
        x_3 = F.relu(self.fc3(x_2))  # 256维度的特征处理

        # 第一阶段输出特征并 reshape 成 64x3 的中心点特征
        pc1_feat = self.fc3_1(x_3)
        pc1_xyz = pc1_feat.reshape(-1, 64, 3)  # 中心点1，形状为64x3

        # 第二阶段输出特征，并 reshape 为 128x64 的特征
        pc2_feat = F.relu(self.fc2_1(x_2))
        pc2_feat = pc2_feat.reshape(-1, 128, 64)  # 中心点2的特征
        pc2_xyz = self.conv2_1(pc2_feat)  # 处理中心点2

        # 第三阶段输出特征，并经过多个卷积层处理，最终 reshape 为 512x128 的特征
        pc3_feat = F.relu(self.fc1_1(x_1))
        pc3_feat = pc3_feat.reshape(-1, 512, 128)
        pc3_feat = F.relu(self.conv1_1(pc3_feat))
        pc3_feat = F.relu(self.conv1_2(pc3_feat))
        pc3_xyz = self.conv1_3(pc3_feat)  # 细化点云的特征

        # 扩展 pc1_xyz 的维度以便与 pc2_xyz 相加
        pc1_xyz_expand = torch.unsqueeze(pc1_xyz, 2)

        # 转置并 reshape pc2_xyz，然后与扩展后的 pc1_xyz 相加
        pc2_xyz = pc2_xyz.transpose(1, 2)
        pc2_xyz = pc2_xyz.reshape(-1, 64, 2, 3)
        pc2_xyz = pc1_xyz_expand + pc2_xyz
        pc2_xyz = pc2_xyz.reshape(-1, 128, 3)  # 中心点2的坐标

        # 扩展 pc2_xyz 的维度以便与 pc3_xyz 相加
        pc2_xyz_expand = torch.unsqueeze(pc2_xyz, 2)

        # 转置并 reshape pc3_xyz，然后与扩展后的 pc2_xyz 相加
        pc3_xyz = pc3_xyz.transpose(1, 2)
        pc3_xyz = pc3_xyz.reshape(-1, 128, int(self.crop_point_num / 128), 3)
        pc3_xyz = pc2_xyz_expand + pc3_xyz
        pc3_xyz = pc3_xyz.reshape(-1, self.crop_point_num, 3)  # 细化后的点云坐标

        # 返回第一阶段、第二阶段和最终阶段的点云坐标
        return pc1_xyz, pc2_xyz, pc3_xyz  # 返回中心点1、中心点2和细化点

Discriminator

判別器，与GAN中的判别器逻辑一模一样，有两组输入，对比是否预测准确，实际上就是做了一个二分类，输出每个点结果为True或False，表示预测是否正确。

class _netlocalD(nn.Module)：
	# ...
    def forward(self, x):
        # 输入经过第一个卷积层和批归一化后激活
        x = F.relu(self.bn1(self.conv1(x)))

        # 输入经过第二个卷积层和批归一化后激活，得到 64 维的特征
        x_64 = F.relu(self.bn2(self.conv2(x)))

        # 输入经过第三个卷积层和批归一化后激活，得到 128 维的特征
        x_128 = F.relu(self.bn3(self.conv3(x_64)))

        # 输入经过第四个卷积层和批归一化后激活，得到 256 维的特征
        x_256 = F.relu(self.bn4(self.conv4(x_128)))

        # 对 64 维特征进行最大池化并 squeeze 以减少维度
        x_64 = torch.squeeze(self.maxpool(x_64))

        # 对 128 维特征进行最大池化并 squeeze 以减少维度
        x_128 = torch.squeeze(self.maxpool(x_128))

        # 对 256 维特征进行最大池化并 squeeze 以减少维度
        x_256 = torch.squeeze(self.maxpool(x_256))

        # 将 64、128 和 256 维的特征拼接在一起
        Layers = [x_256, x_128, x_64]
        x = torch.cat(Layers, 1)

        # 全连接层逐层缩小特征维度并进行激活
        x = F.relu(self.bn_1(self.fc1(x)))
        x = F.relu(self.bn_2(self.fc2(x)))
        x = F.relu(self.bn_3(self.fc3(x)))

        # 最后一层全连接层输出结果
        x = self.fc4(x)

        return x