1. 修改requirements.txt文件：

   1. 第59行：注释torch==2.2.0+cu118；
   2. 第61行：注释torchvision==0.17.0+cu118。

2. 创建环境：

   1	conda create --name unopose python=3.10.12

3. 激活环境：

   1	conda activate unopose

4. 安装依赖：

   1 2 3 4 5 6

   pip3 install torch==2.0.0 torchvision==0.15.0 --index-url https://download.pytorch.org/whl/cu117 pip3 install mmcv==2.2.0 -f https://download.openmmlab.com/mmcv/dist/cu117/torch2.0/index.html pip3 install -r requirements.txt python -m pip install 'git+https://github.com/facebookresearch/detectron2.git'

5. 安装bop_toolkit：

   1 2	cd third_party/bop_toolkit python setup.py install

6. 安装pointnet2：

   1 2	cd core/unopose/model/pointnet2/ pip3 install -e .

下载数据集

1. 在代码对应的HuggingFace🤗数据集仓库中下载数据集配对文件：

   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/CustomSamAutomaticMaskGeneratorOnerefTargetsCrosssceneRot50Refvisib_ycbv-test.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/CustomSamAutomaticMaskGenerator_test_oneref_targets_crossscene_rot50_refvisib_ycbv.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/megapose_gso_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/megapose_gso_fixed_valid_inst_ids.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/megapose_shapenetcore_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/megapose_shapenetcore_fixed_valid_inst_ids.json
   • https://huggingface.co/datasets/shanice-l/UNOPose_data/resolve/main/test_ref_targets_crossscene_rot50.json

2. 下载YCB-V数据集的部分数据：

   • https://huggingface.co/datasets/bop-benchmark/ycbv/resolve/main/ycbv_test_all.zip
   • https://huggingface.co/datasets/bop-benchmark/ycbv/resolve/main/ycbv_models.zip
   • https://huggingface.co/datasets/bop-benchmark/ycbv/resolve/main/ycbv_base.zip

下载预训练模型

执行：

1

python core/unopose/scripts/download_and_save_dinov2_ckpt.py

下载的预训练模型如下：

1
2

$ ls checkpoints/
timm_vit_base_patch14_reg4_dinov2_lvd142m.pth

运行代码

解压ycbv_test_all.zip，并将上述下载的7个配对文件组织如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

datasets
├── BOP_DATASETS
│   └── ycbv
│       ├── models_eval -> /data1/dataset/unopose/ycbv/models_eval/
│       ├── test -> /data1/dataset/unopose/ycbv/test/
│       ├── test_ref_targets_crossscene_rot50.json -> /data1/dataset/unopose/test_ref_targets_crossscene_rot50.json
│       └── test_targets_bop19.json -> /data1/dataset/unopose/ycbv/ycbv/test_targets_bop19.json
├── MegaPose-Training-Data
│   ├── megapose_gso_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json -> /data1/dataset/unopose/megapose_gso_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json
│   ├── megapose_gso_fixed_valid_inst_ids.json -> /data1/dataset/unopose/megapose_gso_fixed_valid_inst_ids.json
│   ├── megapose_shapenetcore_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json -> /data1/dataset/unopose/megapose_shapenetcore_fixed_obj_id_to_visib0_8_scene_im_inst_ids.json
│   └── megapose_shapenetcore_fixed_valid_inst_ids.json -> /data1/dataset/unopose/megapose_shapenetcore_fixed_valid_inst_ids.json
└── segmentation
    └── CustomSamAutomaticMaskGenerator_test_oneref_targets_crossscene_rot50_refvisib_ycbv.json -> /data1/dataset/unopose/CustomSamAutomaticMaskGenerator_test_oneref_targets_crossscene_rot50_refvisib_ycbv.json

6 directories, 7 files

执行：

1

./core/unopose/save_unopose.sh configs/main_cfg.py <gpu_ids> checkpoints/timm_vit_base_patch14_reg4_dinov2_lvd142m.pth

• 2025.05.21：两阶段方法，估计两RGBD图像之间的相对位姿。粗略阶段使用GeoTransformer和DINOv2分别提取点云特征和RGB特征，特征拼接后计算相关矩阵，根据矩阵得到若干匹配点对，从这些匹配点对中选择三个可生成一个刚体变换，即位姿假设，使用距离的倒数进行评分，将评分最高的设置为初始位姿；精细阶段在粗略阶段的基础上增加了局部点云信息和位置编码信息，同样得到相关矩阵后使用加权SVD计算位姿。

Abstract

1. Introduction

Our contributions can be summarized as follows:

• To the best of our knowledge, we are the first to conduct unseenobject 6DoF pose estimation leveraging a single unposed RGB-Dreference.
• Based on the BOP Challenge, we devise a new extensive benchmarktailored for unseen object segmentation and pose estimation with onereference. Additionally, we evaluate several traditional andlearning-based methods on this benchmark for completeness.
• We introduce UNOPose, a network for learning relative transformationbetween reference and query objects. To achieve this, we propose the\(SE(3)\)-invariant global and localreference frames, enabling standardized object representations despitevariations in pose and size. Furthermore, the network can automaticallyadjust the confidence of each correspondence by incorporating an overlappredictor.

2. Related Work

3. UNO ObjectSegmentation and Pose Estimation

3.1. Problem Formulation

假设查询图像中存在一个任意的、未见过的刚性物体，我们的目标是利用一张展示目标物体且无严重遮挡或截断的带掩码RGBD参考图像，估计该物体的掩码\(M_q\)及其6D相对位姿\(\Delta \mathbf{T} \inSE(3)\)。如图1所示，输入包括：

1. \([I_q | D_q] \in \mathbb{R}^{H \times W\times 4}\)：查询RGBD图像；
2. \([I_p | D_p] \in \mathbb{R}^{H \times W\times 4}\) 和 \(M_p \in \mathbb{R}^{H\times W}\)：参考RGBD图像及指示目标物体的对应二值掩码；
3. \(K_q \in \mathbb{R}^{3 \times 3}\)和 \(K_p \in \mathbb{R}^{3 \times3}\)：查询图像与参考图像的相机内参。

可选地，如果参考物体在相机坐标系中的位姿\(\mathbf{T}_p \inSE(3)\)已知，则查询物体的位姿\(\mathbf{T}_q \in SE(3)\)可通过\(\mathbf{T}_q = \Delta \mathbf{T}\mathbf{T}_p\)恢复。需要注意的是，从实用性角度出发，该方法不应依赖参考物体的绝对位姿，因为世界坐标系在不同应用中可能任意变化。我们仅在推理阶段对标准物体位姿数据集进行评估时使用参考物体的位姿。

3.2. UNO Object Segmentation

首先，我们需要从杂乱的背景中分割出查询图像中的目标物体。得益于视觉基础模型强大的泛化能力，像“ZeroPose:CAD-Prompted Zero-shot Object 6D Pose Estimation in ClutteredScenes”、“SAM-6D: Segment Anything Model Meets Zero-Shot 6D Object PoseEstimation”和“CNOS: A Strong Baseline for CAD-based Novel ObjectSegmentation”等方法能够利用CAD模型对新物体进行有效分割。然而，与以往从多个渲染视图生成多样描述符的方法不同，我们仅能获取单张参考图像。为应对这一挑战，我们采用SAM模型[40]从查询图像中预测所有可能的掩码提议，然后通过余弦相似度比较查询图像与参考图像的DINOv2[65]描述符，对每个掩码提议进行评分，从而筛选出最相似的掩码\(M_q\)。关于UNO分割的更多细节请参见附录。

3.3. UNO Object Pose Estimation

3.3.1. Overview of UNOPose

给定查询图像的预测掩码\(M_q\)和参考图像的掩码\(M_p\)，我们从深度图\(D_q\)和\(D_p\)中裁剪出目标物体，并将其反投影到相机空间，得到两个点集\(\mathbf{Q}_{cam} \in \mathbb{R}^{N^Q \times3}\)和\(\mathbf{P}_{cam} \in\mathbb{R}^{N^P \times 3}\)，其中\(N^Q\)和\(N^P\)分别表示查询点云和参考点云的点数。我们的目标是通过最小化对应点距离来恢复相对变换\(\Delta \mathbf{T} = \{\Delta \mathbf{R}, \Delta\mathbf{t}\}\)

\[\begin{equation}\label{eq1} \min\sum_{(\mathbf{q}, \mathbf{p}) \in \mathbf{C}}\Vert\Delta\mathbf{R}\mathbf{q} + \Delta\mathbf{t} - \mathbf{p}\Vert_2,\end{equation}\]

其中\(\mathbf{C}\)是预测的\(\mathbf{Q}_{cam}\)与\(\mathbf{P}_{cam}\)之间的对应点集。我们利用颜色和几何线索构建该对应关系，并遵循点云配准中广泛使用的由粗到细范式来求解公式\(\eqref{eq1}\)。网络结构如图2所示。

3.3.2. Coarse-to-fine PoseEstimation

Constructing a Pose-invariant ReferenceFrame.：仅给定一张未标定位姿的参考图像时，待预测的相对位姿在\(SE(3)\)空间中具有任意性，这对实现鲁棒的对应关系构成了重大挑战。因此，我们引入一个位姿无关全局参考框架（GRF），并将\(\mathbf{Q}_{cam}\)和\(\mathbf{P}_{cam}\)转换到GRF中，得到\(\mathbf{Q}_G\)和\(\mathbf{P}_G\)。

具体来说，以\(\mathbf{Q}_{cam}\)为例，将点云转换为全局参考框架（GRF）涉及7D坐标变换\(\{\mathbf{R}_G \in SO(3), \mathbf{t}_G \in\mathbb{R}^3, s_G \in \mathbb{R}\}\)：

\[\begin{equation}\label{eq2} \mathbf{Q}_G = \{\frac{\mathbf{R}_G^T(\mathbf{q} -\mathbf{t}_G)}{s_G} \mid \mathbf{q} \in \mathbf{Q}_{cam}\}.\end{equation}\]

为实现平移不变性，GRF的原点位于物体中心\(\mathbf{c}_Q\)；为实现尺寸不变性，点云半径会重新缩放为\(1\)，计算方式为：

\[\begin{equation}\label{eq3} \mathbf{t}_G = \mathbf{c}_Q, \quad s_G = \max_{\mathbf{q} \in\mathbf{Q}_{cam}} \Vert\mathbf{q} - \mathbf{c}_Q\Vert_2.\end{equation}\]

关键在于设计旋转矩阵\(\mathbf{R}_G =[\mathbf{r}_{Gx} | \mathbf{r}_{Gy} |\mathbf{r}_{Gz}]\)，其中\(\mathbf{r}_{Gx}, \mathbf{r}_{Gy},\mathbf{r}_{Gz}\)为\(\mathbf{R}_G\)的三列，用于确保变换后点云的方向不变性。受前人工作“RecognizingObjects in Range Data Using Regional Point Descriptors”、“Structuralindexing: efficient 3-D object recognition”和“TOLDI: An effective androbust approach for 3D local shapedescription”的启发，我们将物体中心的法向量\(\mathbf{n}(\mathbf{c}_Q)\)作为\(\mathbf{r}_{Gz}\)，将\(\mathbf{Q}_{cam}\)中所有点投影到\(\mathbf{c}_Q\)的切平面上，通过统计投影向量确定\(\mathbf{r}_{Gx}\)，然后通过叉乘\(\mathbf{r}_{Gy} = \mathbf{r}_{Gx} \times\mathbf{r}_{Gz}\)得到\(\mathbf{r}_{Gy}\)。这确保XY平面均匀分割点云，且x轴代表主投影方向。GRF具有\(SE(3)\)无关性，因其可由点云的空间分布唯一确定，使变换后的点云对位姿和尺寸变化具有鲁棒性。

具体来说，我们对协方差矩阵\(\text{Cov}(\mathbf{Q}_{cam}) = \frac{1}{N_Q}\mathbf{Q}_{cam}^T \mathbf{Q}_{cam} - \mathbf{c}_Q\mathbf{c}_Q^T\)进行奇异值分解（SVD），并使用与最小奇异值对应的奇异向量来确定\(\mathbf{r}_{Gz}\)：

\[\begin{equation}\label{eq4} \mathbf{r}_{Gz} = \begin{cases} \mathbf{n}(\mathbf{c}_Q), & \text{if }\mathbf{n}(\mathbf{c}_Q)^T\sum_{\mathbf{q} \in\mathbf{Q}_{cam}}(\mathbf{c}_Q - \mathbf{q}) > 0 \\ -\mathbf{n}(\mathbf{c}_Q), & \text{otherwise} \end{cases}\end{equation}\]

随后，\(r_{Gx}\)的计算公式为：

\[\begin{equation}\label{eq5} \mathbf{r}_{Gx} = \sum_{\mathbf{q} \in\mathbf{Q}_{cam}}w_q((\mathbf{q} - \mathbf{c}_Q) -\mathbf{r}_{Gz}^T(\mathbf{q} - \mathbf{c}_Q)\mathbf{r}_{Gz}),\end{equation}\]

其中\(w_q\)是关于点\(\mathbf{q}\)与物体中心\(\mathbf{c}_Q\)之间距离的权重（具体细节见附录）。

以往的工作“Leveraging SE(3) Equivariance for Self-SupervisedCategory-Level Object Pose Estimation”、“CPPF: Towards RobustCategory-Level 9D Pose Estimation in the Wild”和“Rotation-InvariantTransformer for Point CloudMatching”通常依赖复杂网络或计算成本高昂的PPF特征来实现\(SE(3)\)无关性。相比之下，我们的变换方法计算效率高，并且能够无缝适配多种网络架构。

Coarse Pose Estimation.：给定GRF中的点云\(\mathbf{Q}_G\)和\(\mathbf{P}_G\)，我们采样两个稀疏点集\(\mathbf{Q}_G^c \in \mathbb{R}^{N^c \times3}\)和\(\mathbf{P}_G^c \in\mathbb{R}^{N^c \times 3}\)以高效获取粗位姿初始化\(\Delta\mathbf{T}_{init}\)。具体而言，我们利用几何编码器“GeoTransformer:Fast and Robust Point Cloud Registration with GeometricTransformer”和颜色编码器“DINOv2: Learning Robust Visual Features withoutSupervision”分别提取点云和RGB特征。特征进一步拼接为\(f_Q^c \in \mathbb{R}^{N^c \timesd}\)和\(f_P^c \in \mathbb{R}^{N^c\times d}\)，其中\(d\)为嵌入维度。遵循“SAM-6D: SegmentAnything Model Meets Zero-Shot 6D Object PoseEstimation”，我们添加可学习的背景标记以分配非重叠点。这些嵌入表示为\(\hat{f}_Q^c \in \mathbb{R}^{(N^c + 1) \timesd}\)和\(\hat{f}_P^c \in\mathbb{R}^{(N^c + 1) \times d}\)，并通过三个堆叠的GeometricTransformer解码模块进行处理。

最后一个解码器的输出\(\hat{F}_Q^c \in\mathbb{R}^{(N^c + 1) \times D}\)和\(\hat{F}_P^c \in \mathbb{R}^{(N^c + 1) \timesD}\)是用于构建相关矩阵的逐点特征。然而，在我们的场景中，重叠率可能受到视点、遮挡或深度噪声等复杂因素的影响。为解决这一问题，网络额外预测重叠置信度\(\hat{O}_Q^c \in \mathbb{R}^{(N^c + 1) \times1}\)和\(\hat{O}_P^c \in\mathbb{R}^{(N^c + 1) \times1}\)，表示各点属于重叠区域的概率。因此，重叠感知相关矩阵\(\mathbf{X}_c \in \mathbb{R}^{(N^c + 1) \times (N^c+ 1)}\)可通过下式计算：

\[\begin{equation}\label{eq6} \mathbf{X}^c = \text{softmax}[(\hat{O}_Q^c \odot\hat{F}_Q^c)(\hat{O}_P^c \odot \hat{F}_P^c)^T].\end{equation}\]

这里\(\odot\)表示元素级乘法。\(\mathbf{X}^c\)中的每个元素表示\(\mathbf{Q}^c\)与\(\mathbf{P}^c\)中点对之间的相关分数。

在计算出相关矩阵\(\mathbf{X}^c\)后，我们可以提取\(\mathbf{Q}^c\)和\(\mathbf{P}^c\)之间所有可能的对应点对及其相关分数，从而求解公式\(\eqref{eq1}\)。具体来说，我们首先根据\(\mathbf{X}^c\)的分布采样\(N_H\)个点对三元组，生成位姿假设。然后，每个位姿假设\(\Delta \mathbf{T}_h = \{\Delta \mathbf{R}_h,\Delta \mathbf{t}_h\}\)按照“SurfEmb: Dense and ContinuousCorrespondence Distributions for Object Pose Estimation with LearntSurface Embeddings”和“SAM-6D: Segment Anything Model Meets Zero-Shot 6DObject Pose Estimation”中的方法，通过距离\(D_h\)的倒数进行评分：

\[\begin{equation}\label{eq7} \begin{aligned} D_h &= \frac{1}{N^c}\sum_{\mathbf{p}^c \in\mathbf{P}^c}\min_{\mathbf{q}^c \in\mathbf{Q}^c}\Vert\Delta\mathbf{R}_h^T(\mathbf{q}^c -\Delta\mathbf{t}_h) - \mathbf{p}^c\Vert_2, \\ \xi_h &= \frac{1}{D_h}, \quad h = 1, 2, \cdots, N_H. \end{aligned}\end{equation}\]

得分\(\xi_h\)最高的位姿假设被选为初始位姿预测值\(\Delta \mathbf{T}_{init} = \{\Delta\mathbf{R}_{init}, \Delta\mathbf{t}_{init}\}\)，并进一步用于变换下一阶段的输入。

Fine Pose Estimation.：在使用初始位姿预测\(\Delta \mathbf{T}_{init}\)将\(\mathbf{Q}_{cam}\)变换为\(\tilde{\mathbf{Q}}_{cam}\)之后，我们在两个密集点集，即\(\tilde{\mathbf{Q}}^f \in \mathbb{R}^{N^f \times3}\)和\(\mathbf{P}^f \in\mathbb{R}^{N^f \times3}\)之间执行精细匹配过程，以获得更精确的位姿。该网络通过分层编码范式利用几何细节，包括位置编码层和局部参考框架编码层。对于每个点，我们首先使用小型PointNet，即“PointNet:Deep Learning on Point Sets for 3D Classification andSegmentation”对其全局位置进行编码，然后构建\(SE(3)\)无关局部参考框架（LRF）以收集局部描述符。这两种编码相互补充，因为局部描述符捕获小邻域内的精细几何结构，而位置编码层提供全局几何上下文。

以\(\tilde{\mathbf{Q}}^f\)为例，构建局部参考框架（LRF）编码的过程如下：对于\(\tilde{\mathbf{Q}}^f\)中的每个点\(\tilde{\mathbf{q}}^m\)，通过将\(\tilde{\mathbf{q}}^m\)的\(N_D\)个邻近点分组，构建局部区域集合\(\tilde{\mathcal{Q}}^m = \{\tilde{\mathbf{q}}_j,\text{where } \Vert\tilde{\mathbf{q}}_j - \tilde{\mathbf{q}}^m\Vert_2\leq r\}_{j = 1}^{N_D}\)。LRF的变换位姿\(\{\mathbf{R}_L^m, \mathbf{t}_L^m,s_L^m\}\)的计算方式与GRF类似（见公式\(\eqref{eq3}\)、\(\eqref{eq4}\)、\(\eqref{eq5}\)），区别在于LRF基于局部点集构建，而GRF基于整个点云。通过计算变换位姿，我们将局部点描述符计算为：

\[\begin{equation}\label{eq8} \begin{aligned} \mathcal{Q}_L^m &= \tilde{\mathcal{Q}}_L^m =\{(\mathbf{R}_L^m)^T(\frac{\tilde{\mathbf{q}}_j -\mathbf{t}_L^m}{s_L^m})\}_{j = 1}^{N_D}, \\ \mathbf{Q}_L^f &= \{\mathcal{Q}_L^m\}_{m = 1}^{N^f}. \end{aligned}\end{equation}\]

类似地，我们将\(\mathbf{P}^f\)变换为\(\mathbf{P}_L^f\)。注意，由于LRF是位姿无关的，因此\(\mathcal{Q}_L^m =\tilde{\mathcal{Q}}_L^m\)。然后，通过三层MLP从\(\mathbf{Q}_L^f\)和\(\mathbf{P}_L^f\)中提取LRF编码。

位置编码和LRF编码与几何和颜色特征相结合，作为几何Transformer的输入。与初始位姿预测类似，通过解码这些特征，我们获得精细的逐点特征\(\hat{F}^f_Q\)、\(\hat{F}^f_P\)以及重叠置信度\(\hat{O}^f_Q\)、\(\hat{O}^f_P\)，然后利用这些结果得到考虑重叠区域的精细相关矩阵\(\mathbf{X}^f \in \mathbb{R}^{(N^f + 1) \times (N^f+ 1)}\)。最终位姿\(\Delta\mathbf{T}\)通过使用加权SVD算法对\(\mathbf{X}^f\)求解公式\(\eqref{eq1}\)来预测。

4. Experiments

5. Conclusion, Limitationand Future work

• 2025.05.19：One2Any估计两张RGBD间的相对位姿，从NOCS中获得启发，One2Any直接从Ref中得到规范空间，使用Umeyama算法，将后续的Query与这个规范空间对齐，得到相对位姿。

Abstract

1. Introduction

2. Related Works

3. Method

3.1. Overview

我们将问题表述为：给定单张参考RGBD图像和查询RGBD图像的相对物体位姿估计，且不依赖CAD模型或多视角图像。给定一幅参考RGBD图像，其RGB图像为\(A_I \in\mathbb{R}^{W \times H \times 3}\)，深度图像为\(A_D \in \mathbb{R}^{W \timesH}\)，目标物体掩码为\(A_M \in \{0,1\}^{W \times H}\)，我们的目标是预测查询图像输入\(Q_I \in \mathbb{R}^{W \times H \times3}\)、\(Q_D \in \mathbb{R}^{W \timesH}\)、\(Q_M \in \{0, 1\}^{W \timesH}\)中目标物体相对于参考视角中目标物体的位姿\([\mathbf{R} |\mathbf{t}]\)。我们的核心思想是学习一个具有参数\(\theta_A\)的参考物体编码器（ROE）\(f_A\)，将参考输入\(A = [A_I, A_D,A_M]\)嵌入到参考物体位姿嵌入（ROPE）中。通过在大型数据集上训练\(f_A\)，嵌入向量\(\mathbf{e}_A\)为物体位姿解码（OPD）模块提供条件，以生成查询图像的参考物体坐标（ROC）图。我们在图2中展示了网络架构。OPD模块包含用于提取查询图像特征并预测ROC图的编码器-解码器架构，这通过使用U-Net架构与ROPE集成得到进一步增强。在此，我们将具有参数\(\theta_Q\)的\(g_{\theta_Q}\)记为OPD模块，其将查询图像\(Q\)作为输入以预测输出ROC：\(Y_Q \in \mathbb{R}^{W \times H \times3}\)。于是，我们可以将整体问题表述为：

\[\begin{equation}\label{eq1} Y_Q = g(Q, f_A(A; \theta_A); \theta_Q)\end{equation}\]

3.2. Reference ObjectCoordinate (ROC)

如3.1节所述，我们的目标是估计单张参考图像\(A\)与单张查询图像\(Q\)之间的相对位姿\([\mathbf{R} |\mathbf{t}]\)。为此，我们受NOCS启发，提出使用一种称为参考物体坐标（ROC）的2D-3D映射。与NOCS不同的是，我们的方法无需规范坐标系，而是直接在参考相机坐标系中表示物体坐标。因此，ROC仅由参考坐标系定义，查询图像中的物体需变换至与参考坐标系对齐，并归一化到ROC空间中。

尽管这一改动看似简单，但对训练和推理均有重要影响。根据定义，NOCS要求将同一类别的所有物体对齐到单一规范空间，而ROC图的生成要容易得多，仅需一对参考图像和查询图像，即可直接为相对位姿估计提供合适的表示。

为了从参考视图构建ROC，我们首先通过深度值反投影像素坐标来获取参考物体的部分点云\(P_A\)：

\[\begin{equation}\label{eq2} P_A = \mathbf{K}^{-1}A_D[A_M = 1]\end{equation}\]

然后，我们通过对\(P_A\)的齐次坐标应用变换\(\mathbf{S} \in \mathbb{R}^{4 \times4}\)来获得ROC。

\[\begin{equation}\label{eq3} Y_A = \mathbf{S}P_A\end{equation}\]

在此对符号稍作扩展，我们将映射\(A_I \toY_A\)的ROC记为\(Y_A\)。类似地，为了获取查询图像的ROC真实值，我们首先使用真实相对位姿\([\mathbf{R} |\mathbf{t}]\)变换将查询点云转换到参考视图下，然后应用相同的缩放和平移变换\(\mathbf{S}\)。

\[\begin{equation}\label{eq4} Y_Q = \mathbf{S}([\mathbf{R} | \mathbf{t}]P_Q)\end{equation}\]

图3展示了构建ROC图的过程。图的上半部分显示了从参考RGBD图像生成ROC图\(Y_A\)的过程，下半部分则展示了真实查询ROC图\(Y_Q\)的生成过程。该方法基于参考坐标系建立了一个物体空间，该空间会随着参考物体及其位姿的变化而动态调整。

3.3. Reference Object PoseEmbedding

在仅给定单张RGBD参考图像的情况下，对查询RGBD图像进行位姿预测面临着独特的挑战。以往的方法通常依赖关键点特征匹配，如“High-resolutionopen-vocabulary object 6D pose estimation”、“POPE: 6-DoF Promptable PoseEstimation of Any Object, in Any Scene, with One Reference”和“NOPE:Novel Object Pose Estimation from a SingleImage”，但当图像中的可见区域重叠度较低或被严重遮挡时，这些方法就会失效。我们提出了一种替代方法，将参考图像编码为参考物体位姿嵌入（ROPE），从而能够有效地预测物体位姿。我们的目标是训练一个参考物体编码器（ROE），使其能够从单张RGBD参考图像中在潜在空间生成全面的物体表示。然后，ROPE表示可以从同一物体的任何测试图像中有效地预测参考相机空间中的ROC图，从而实现准确的位姿估计。

ROE记为\(f(A;\theta_A)\)，其设计目的是从由参考RGB图像、参考ROC图和物体掩码组成的通道级联输入\(A\)中提取潜在空间编码。如图2所示，该编码捕获了纹理和几何信息。编码器通过三个带残差连接的卷积层“DeepResidual Learning for ImageRecognition”处理输入，生成特征图，并将其标记化为带位置嵌入的补丁“AnImage is Worth 16x16 Words: Transformers for Image Recognition atScale”。这种条件嵌入可有效引导ROC图的生成，即使在存在遮挡的情况下也能保持对参考数据的保真度，如4.8节所示。

3.4. Object Pose Decoding withROPE

OPD模块\(g(Q, f ;\theta_Q)\)基于从参考图像中提取的ROPE，对查询图像中的物体位姿进行解码。在具有代表性的ROPE的强监督下，OPD模块通过生成查询图像的ROC图来预测物体的位姿。

OPD架构采用了受StableDiffusion启发的编码器-解码器结构。为了更好地聚合ROPE表示，我们通过交叉注意力层集成来自查询图像的信息。具体来说，我们使用“High-resolutionopen-vocabulary object 6D poseestimation”中预训练的VQVAE模型来充分提取查询RGB图像\(Q_I\)的特征图，并进一步提升模型的泛化能力。我们随后通过交叉注意力层，对以代表性ROPE为条件的类UNet网络“High-resolutionopen-vocabulary object 6D poseestimation”进行微调。图2展示了详细架构。该U-Net通过交叉注意力机制整合查询特征\(\mathcal{F}^Q\)和参考嵌入\(\mathcal{F}^A\)（即ROPE）。具体而言，在每个交叉注意力层中，查询特征\(\mathcal{F}^Q\)与来自\(\mathcal{F}^A\)的键\(k \in \mathbb{R}^{m \timesd_k}\)和值嵌入\(v \in \mathbb{R}^{m\times d_v}\)进行交互。

\[\begin{equation}\label{eq5} k = \mathcal{F}^A \times W_k, \quad v = \mathcal{F}^A \times W_v,\quad \mathcal{F}^Q = \mathcal{F}^Q \times W_q\end{equation}\]

其中\(W\)表示每个向量的权重矩阵，且交叉注意力应用于查询向量\(q\)、键向量\(k\)和值向量\(v\)之间，

\[\begin{equation}\label{eq6} \text{Attention}(q, k, v) =\text{softmax}\left(\frac{qk^T}{\sqrt{d_k}}\right)v\end{equation}\]

\(d_k\)是键向量\(k\)的维度，用于缩放操作，该操作在注意力机制中用于确保梯度稳定。最终的相对特征图\(\mathcal{F}^{Q2A}\)通过U-Net架构中的多个交叉注意力层实现。该架构使网络能够充分提取嵌入在ROPE中的位姿-形状信息。

解码器随后对\(F^{Q2A}\)进行逐步细化和上采样，将其重建为原始图像尺寸。该解码器由五个包含残差连接和双线性上采样的卷积层构成，生成ROC图\(\hat{Y}_Q\)，其准确表示了查询视图在ROC空间中的坐标。

ROC map loss.遵循NOCS的方法，我们通过使用平滑L1损失函数，来自“Faster R-CNN: TowardsReal-Time Object Detection with Region ProposalNetworks”，监督ROC图预测值\(\hat{Y}_Q\)与真实ROC图\(Y_Q\)的一致性来训练网络\(\{f, g\}\)，损失函数定义为：

\[\begin{equation}\label{eq7} \begin{aligned} \mathcal{L} &= \frac{1}{N} \sum_i \sum_j Q_M(i, j)E(i, j) \\ c &= Y_Q(i, j) - \hat{Y}_Q(i, j) \\ E(i, j) &= \begin{cases} \frac{0.5(c)^2}{\beta}, & (|c| < \beta) \\ |c| - 0.5\beta, & \text{otherwise} \end{cases} \end{aligned}\end{equation}\]

\(\beta\)为平滑阈值，设置为0.1。对于物体掩码像素位置，\(Q_M(i, j)=1\)，否则为0。

3.5. Pose Estimation from ROCMap

相对位姿\([\mathbf{R} |\mathbf{t}]\)通过测量预测的ROC图\(\hat{Y}_Q\)与查询视点云\(P_Q\)之间的变换来计算。注意，参考相机的位姿为\([\mathbf{I}_3 |\mathbf{0}]\)。首先，我们使用参考ROC的缩放矩阵的逆\(\mathbf{S}^{-1}\)对预测的ROC图\(\hat{Y}_Q\)进行平移和缩放，使其与参考相机坐标系对齐。由此得到的点云\(\hat{P}_Q^A\)表示参考相机坐标系下的查询物体。结合查询点云\(P_Q\)，我们使用Umeyama方法来获取查询坐标系与参考坐标系之间的位姿预测\([\hat{\mathbf{R}} |\hat{\mathbf{t}}]\)。数学上，我们可以将其表示为：

\[\begin{equation}\label{eq8} \begin{aligned} \hat{P}_Q^A &= \mathbf{S}^{-1}\hat{Y}_Q[Q_M = 1] \\ [\hat{\mathbf{R}} | \hat{\mathbf{t}}] &= \text{Umeyama}(P_Q,\hat{P}_Q^A) \end{aligned}\end{equation}\]

4. Experimental Results

5. Conclusions

到目前为止跑不起来，很多报错。

安装GIVEPose环境

1. 修改GIVEPose_env.yml文件：

   1. 第1行：name: dinov2 ->name: givepose；
   2. 第192行：注释- xformers=0.0.21=py39_cu11.8.0_pyt2.0.1；
   3. 第217行：注释- dcnv3==1.1；
   4. 第268行：注释- pydensecrf==1.0rc2。

2. 创建环境：

   1	conda env create -f GIVEPose_env.yml

3. 激活环境：

   1	conda activate givepose

4. 安装dcnv3、pydensecrf和detectron2：

   1 2 3 4 5 6 7

   cd network/ops_dcnv3/ sh make.sh cd ../../ pip3 install git+https://github.com/lucasb-eyer/pydensecrf.git python -m pip install 'git+https://github.com/facebookresearch/detectron2.git'

5. Clone mentian/object-deformnet并安装nn_distance，需要使用该仓库中的代码进行数据处理：

   1 2 3 4

   git clone https://github.com/mentian/object-deformnet.git cd lib/nn_distance python setup.py install

6. Clone lolrudy/LaPose，需要使用该仓库中的代码进行数据处理：

   1	git clone https://github.com/lolrudy/LaPose.git

下载数据集

1. 下载NOCS数据集：

   • http://download.cs.stanford.edu/orion/nocs/camera_composed_depth.zip
   • http://download.cs.stanford.edu/orion/nocs/camera_train.zip
   • http://download.cs.stanford.edu/orion/nocs/camera_val25K.zip
   • http://download.cs.stanford.edu/orion/nocs/gts.zip
   • http://download.cs.stanford.edu/orion/nocs/obj_models.zip
   • http://download.cs.stanford.edu/orion/nocs/real_test.zip
   • http://download.cs.stanford.edu/orion/nocs/real_train.zip

2. 下载NOCS数据集中缺失的物体模型（From: https://github.com/mentian/object-deformnet/issues/3#issuecomment-698858332）：

   • https://drive.google.com/file/d/1rWkxEVJJh_kWIqxudn_i6sJ-hhd0E7TV/

3. 下载Gorilla-Lab-SCUT/DualPoseNet的分割结果（LaPose使用该分割结果对数据进行预处理）：

   • https://drive.google.com/file/d/1RwAbFWw2ITX9mXzLUEBjPy_g-MNdyHET/

4. 下载使用mentian/object-deformnet进行数据预处理时用到的数据到仓库文件夹中：

   • https://drive.google.com/file/d/1p72NdY4Bie_sra9U8zoUNI4fTrQZdbnc/

5. 下载GIVEPose训练时使用的IVFC map：

   • https://drive.google.com/file/d/1kF8ck7EM9mnz6jyySncVUxzXgRxHH9e-/

处理数据集

mentian/object-deformnet

请参考https://blog.032802.xyz/code-running/Leeiieeo_AG-Pose.html#mentianobject-deformnet的处理过程，这里不再重复

lolrudy/LaPose

遵循lolrudy/LaPose的处理方式，首先解压上述文件，并组织如下，注意，data文件夹位于LaPose文件夹下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

data
├── camera -> /data1/dataset/nocs/tanmx/lapose/camera
│   ├── train
│   └── val
├── camera_full_depths -> /data1/dataset/nocs/tanmx/lapose/camera_full_depths/
│   ├── train
│   └── val
├── deformnet_eval -> /data1/dataset/nocs/tanmx/lapose/deformnet_eval
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/lapose/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/lapose/obj_models/
│   ├── camera_train.pkl
│   ├── camera_val.pkl
│   ├── mug_meta.pkl
│   ├── real_test
│   ├── real_test.pkl
│   ├── real_train
│   ├── real_train.pkl
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/lapose/real/
│   ├── test
│   └── train
└── segmentation_results -> /data1/dataset/nocs/tanmx/lapose/data/segmentation_results/
    ├── CAMERA25
    └── REAL275

25 directories, 5 files

1
2
3
4
5
6
7
8
9
10
11
12
13

$ ls -l data/obj_models/
total 31520
drwxr-xr-x  6 tanmx tanmx     4096 May  3 12:11 ./
drwxrwxr-x  9 tanmx tanmx     4096 May  3 12:08 ../
-rw-rw-r--  1 tanmx tanmx 26695895 May  3 12:11 camera_train.pkl
-rw-rw-r--  1 tanmx tanmx  4634293 May  3 12:11 camera_val.pkl
-rw-rw-r--  1 tanmx tanmx    23197 May  3 12:11 mug_meta.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_test/
-rw-rw-r--  1 tanmx tanmx   443600 May  3 12:11 real_test.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_train/
-rw-rw-r--  1 tanmx tanmx   443584 May  3 12:11 real_train.pkl
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 train/
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 val/

按顺序执行：

1
2

python prepare_data/pose_data.py
python prepare_data/shape_data.py

执行python prepare_data/pose_data.py后目录变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

data
├── camera -> /data1/dataset/nocs/tanmx/lapose/camera
│   ├── train
│   ├── train_list_all.txt
│   ├── train_list.txt
│   ├── val
│   ├── val_list_all.txt
│   └── val_list.txt
├── camera_full_depths -> /data1/dataset/nocs/tanmx/lapose/camera_full_depths/
│   ├── train
│   └── val
├── deformnet_eval -> /data1/dataset/nocs/tanmx/lapose/deformnet_eval
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/lapose/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/lapose/obj_models/
│   ├── camera_train.pkl
│   ├── camera_val.pkl
│   ├── mug_meta.pkl
│   ├── real_test
│   ├── real_test.pkl
│   ├── real_train
│   ├── real_train.pkl
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/lapose/real/
│   ├── test
│   ├── test_list_all.txt
│   ├── test_list.txt
│   ├── train
│   ├── train_list_all.txt
│   └── train_list.txt
└── segmentation_results -> /data1/dataset/nocs/tanmx/lapose/data/segmentation_results/
    ├── CAMERA25
    └── REAL275

25 directories, 13 files

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

$ ls -l data/camera/
total 9192
drwxrwxr-x     4 tanmx tanmx    4096 May  4 05:44 ./
drwxrwxr-x     9 tanmx tanmx    4096 May  3 12:08 ../
drwxr-xr-x 27502 tanmx tanmx  577536 Jun 14  2019 train/
-rw-rw-r--     1 tanmx tanmx 4675000 May  3 12:13 train_list_all.txt
-rw-rw-r--     1 tanmx tanmx 3403978 May  4 03:26 train_list.txt
drwxr-xr-x  2502 tanmx tanmx   69632 Jun 14  2019 val/
-rw-rw-r--     1 tanmx tanmx  375000 May  3 12:13 val_list_all.txt
-rw-rw-r--     1 tanmx tanmx  288300 May  4 05:44 val_list.txt

$ ls -l data/real/
total 288
drwxrwxr-x 4 tanmx tanmx  4096 May  4 06:02 ./
drwxrwxr-x 9 tanmx tanmx  4096 May  3 12:08 ../
drwxrwxr-x 8 tanmx tanmx  4096 Nov 13  2018 test/
-rw-rw-r-- 1 tanmx tanmx 49572 May  3 12:13 test_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 49572 May  4 06:02 test_list.txt
drwxrwxr-x 9 tanmx tanmx  4096 Jun 14  2019 train/
-rw-rw-r-- 1 tanmx tanmx 82042 May  3 12:13 train_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 82042 May  4 04:51 train_list.txt

$ ls -l data/obj_models/
total 31520
drwxr-xr-x  6 tanmx tanmx     4096 May  3 12:11 ./
drwxrwxr-x  9 tanmx tanmx     4096 May  3 12:08 ../
-rw-rw-r--  1 tanmx tanmx 26695895 May  3 12:11 camera_train.pkl
-rw-rw-r--  1 tanmx tanmx  4634293 May  3 12:11 camera_val.pkl
-rw-rw-r--  1 tanmx tanmx    23197 May  3 12:11 mug_meta.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_test/
-rw-rw-r--  1 tanmx tanmx   443600 May  3 12:11 real_test.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_train/
-rw-rw-r--  1 tanmx tanmx   443584 May  3 12:11 real_train.pkl
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 train/
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 val/

执行python prepare_data/shape_data.py后目录变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

data
├── camera -> /data1/dataset/nocs/tanmx/lapose/camera
│   ├── train
│   ├── train_list_all.txt
│   ├── train_list.txt
│   ├── val
│   ├── val_list_all.txt
│   └── val_list.txt
├── camera_full_depths -> /data1/dataset/nocs/tanmx/lapose/camera_full_depths/
│   ├── train
│   └── val
├── deformnet_eval -> /data1/dataset/nocs/tanmx/lapose/deformnet_eval
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/lapose/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/lapose/obj_models/
│   ├── camera_train.pkl
│   ├── camera_val.pkl
│   ├── mug_meta.pkl
│   ├── real_test
│   ├── real_test.pkl
│   ├── real_train
│   ├── real_train.pkl
│   ├── ShapeNetCore_2048.h5
│   ├── ShapeNetCore_4096.h5
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/lapose/real/
│   ├── test
│   ├── test_list_all.txt
│   ├── test_list.txt
│   ├── train
│   ├── train_list_all.txt
│   └── train_list.txt
└── segmentation_results -> /data1/dataset/nocs/tanmx/lapose/data/segmentation_results/
    ├── CAMERA25
    └── REAL275

25 directories, 15 files

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

$ ls -l data/camera/
total 9192
drwxrwxr-x     4 tanmx tanmx    4096 May  4 05:44 ./
drwxrwxr-x     9 tanmx tanmx    4096 May  3 12:08 ../
drwxr-xr-x 27502 tanmx tanmx  577536 Jun 14  2019 train/
-rw-rw-r--     1 tanmx tanmx 4675000 May  3 12:13 train_list_all.txt
-rw-rw-r--     1 tanmx tanmx 3403978 May  4 03:26 train_list.txt
drwxr-xr-x  2502 tanmx tanmx   69632 Jun 14  2019 val/
-rw-rw-r--     1 tanmx tanmx  375000 May  3 12:13 val_list_all.txt
-rw-rw-r--     1 tanmx tanmx  288300 May  4 05:44 val_list.txt

$ ls -l data/real/
total 288
drwxrwxr-x 4 tanmx tanmx  4096 May  4 06:02 ./
drwxrwxr-x 9 tanmx tanmx  4096 May  3 12:08 ../
drwxrwxr-x 8 tanmx tanmx  4096 Nov 13  2018 test/
-rw-rw-r-- 1 tanmx tanmx 49572 May  3 12:13 test_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 49572 May  4 06:02 test_list.txt
drwxrwxr-x 9 tanmx tanmx  4096 Jun 14  2019 train/
-rw-rw-r-- 1 tanmx tanmx 82042 May  3 12:13 train_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 82042 May  4 04:51 train_list.txt

$ ls -l data/obj_models/
total 116064
drwxr-xr-x  6 tanmx tanmx     4096 May  4 11:15 ./
drwxrwxr-x  9 tanmx tanmx     4096 May  3 12:08 ../
-rw-rw-r--  1 tanmx tanmx 26695895 May  4 10:28 camera_train.pkl
-rw-rw-r--  1 tanmx tanmx  4634293 May  4 10:32 camera_val.pkl
-rw-rw-r--  1 tanmx tanmx    23197 May  4 10:32 mug_meta.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_test/
-rw-rw-r--  1 tanmx tanmx   443600 May  4 10:32 real_test.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_train/
-rw-rw-r--  1 tanmx tanmx   443584 May  4 10:32 real_train.pkl
-rw-rw-r--  1 tanmx tanmx 28951728 May  4 11:15 ShapeNetCore_2048.h5
-rw-rw-r--  1 tanmx tanmx 57616135 May  4 10:35 ShapeNetCore_4096.h5
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 train/
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 val/

运行代码

将数据集组织如下：

• 2025.05.08：这篇文章主要解决的是对称物体的6D位姿估计问题，使用GroupedPrimitives(GP)来对物体分类，GP可以将同一类别的物体（类别是GP的类别，而不是物体的类别）抽象为几个点，以避免由形状引起的不确定性；还设计了位姿距离lossA(M)GPD，该loss曲线上的每一个极小值点都可以映射到一个正确的姿态。

Abstract

1. Introduction

\[\begin{equation}\label{eq1} l = \text{loss}(p, \hat{p}) = \text{loss}(N(I, w), \hat{p}),\end{equation}\]

In summary, the main contributions of this work are as follows.

• We propose a novel feature extraction network XYZNet for the RGB-Ddata, which is suitable for pose estimation with low computational costand superior performance.
• The compact shape representation GP and the distance metric A(M)GPDare introduced to handle symmetries. The loss based on A(M)GPD canconstrain the regression network to converge to the correct state.
• A numerical simulation and visualization method is carried out toanalyze the validity of the A(M)GPD loss. This analytical method isapplicable to other frameworks in 6D pose estimation.
• The framework ES6D is proposed by using XYZNet and the A(M)GPD lossand achieves competitive performance on the YCB-Video and T-LESSdatasets.

2. Related Work

3. The Proposed Method

3.1. Overview

本文的目的是从一幅RGBD图像中检测出刚性物体，并在相机坐标系中估计出相应的旋转\(R \in SO(3)\)和平移\(\boldsymbol{t} \in\mathbb{R}^3\)。为此提出了如下的两阶段方案。

在第一阶段，利用“PoseCNN: A Convolutional Neural Network for 6DObject Pose Estimation in ClutteredScenes”的分割网络来获取目标物体的掩码和边界框。由边界框裁剪得到的每个掩码以及RGBD图像块都会被传送到第二阶段。

在第二阶段，提出了一个名为ES6D的实时框架来估计物体位姿。该框架的流程如图2所示。首先，经过归一化处理后，带掩码的深度像素会被转换为XYZmap。其次，XYZNet从RGB图像块和XYZmap的拼接结果中提取point-wise特征。然后，利用三个卷积头来预测point-wise平移偏移量、四元数以及置信度。最后，选择置信度最高的位姿作为最终结果。

3.2. Point-wise featureextraction

之前的工作“PVN3D: A Deep Point-wise 3D Keypoints Voting Network for6DoF Pose Estimation”和“DenseFusion: 6D Object Pose Estimation byIterative DenseFusion”已经证明，对于6D位姿估计而言，来自RGBD数据的point-wise特征比来自RGB图像的特征更加有效且稳健。最先进的方法PVN3D采用一种异构结构，该结构通过PointNet++获取点云特征，然后通过索引操作将点云特征与RGB特征链接起来。PointNet++通过一系列集合抽象层（SetAbstraction Layers,SAL）来提取局部特征，这些层会在预定义的搜索半径内对点云进行分组。然而，处理大量的点云非常耗时，并且如果我们减少集合抽象层的数量，其表示能力就会下降。2D卷积操作的一个特点是对相邻信息进行分组以提取局部特征。因此，所提出的XYZNet旨在通过对RGB-XYZ图像执行2D卷积操作来同时提取局部特征。

首先，经过掩码处理的深度像素被转换为点云\(\mathcal{P} = \{(x_i, y_i, z_i)\}_{i =1}^N\)，然后使用点的中心\(\boldsymbol{p}_c =\text{mean}(\mathcal{P})\)和一个比例因子\(\gamma\)，将点\(P\)进行平移和缩放到\([-1, 1]\)区间。归一化后的点记为\(\dot{\mathcal{P}} = \{(\dot{x}_i, \dot{y}_i,\dot{z}_i)\}_{i = 1}^N\)，并被格式化为一个XYZ map。通过将XYZmap与相应的RGB patch进行拼接，就可以得到严格对齐的RGB-XYZ数据。“AUnified Framework for Multi-View Multi-Class Object PoseEstimation”中的方法也采用了2D卷积网络从XYZmap中提取点云特征，但其性能远不如异构结构的方法（PVN3D和DenseFusion）。造成这种情况的主要原因是，当在XYZmap上使用2D卷积操作时，点云的空间信息会被丢弃。基于上述观察，我们设计了XYZNet，如图2所示。

XYZNet由三个部分组成：

1. 局部特征提取模块。使用2D卷积层来学习局部特征。设置不同的卷积核大小和下采样率，以扩大感受野。
2. 空间信息编码模块。该模块的主要功能是提取点云特征。该模块将局部特征与XYZmap连接起来，以恢复空间结构，并利用\(1 \times1\)卷积对每个点的局部特征和坐标进行编码。然后，通过最大池化得到全局特征，并将其与每个点的特征连接起来，以提供全局上下文信息。
3. 特征聚合。将局部特征和点云特征连接起来作为point-wise特征。两种模态的融合使得位姿估计在纹理较少和严重遮挡的情况下也具有较强的鲁棒性。

3.3. 6D pose regression

在完成XYZNet后，会得到point-wise特征集合\(F= \{\boldsymbol{f}_i\}_{i = 1}^{N}\)，其中\(\boldsymbol{f}_i \in\mathbb{R}^d\)。在本小节中，我们将阐述如何利用point-wise特征\(\boldsymbol{f}_i\)以及对应的可见点\(\dot{\boldsymbol{p}}_i \in\dot{\mathcal{P}}\)来估计旋转\(R_i \inSO(3)\)和平移\(\boldsymbol{t}_i \in\mathbb{R}^3\)。如图2所示，采用三个\(1\times 1\)卷积头（\(\mathcal{B}_\mathcal{T}\)、\(\mathcal{B}_\mathcal{Q}\)、\(\mathcal{B}_\mathcal{C}\)）来回归平移偏移量（\(\Delta\dot{\boldsymbol{t}}_i \in\mathbb{R}^3\)）、四元数（\(\boldsymbol{q}_i \in \mathbb{R}^4\)且\(\Vert\boldsymbol{q}_i\Vert =1\)）和置信度（\(c_i \in [0,1]\)）。

3D translationregression：将归一化物体坐标系的原点视为一个虚拟关键点，通过计算可见点\(\dot{\boldsymbol{p}}_i\)与原点之间的偏移量\(\Delta\dot{\boldsymbol{t}}_i\)，就可以得到平移量\(\boldsymbol{t}_i\)。其公式如下：

\[\begin{equation}\label{eq2} \Delta\dot{\boldsymbol{t}}_i =\mathcal{B}_\mathcal{T}(\boldsymbol{f}_i),\end{equation}\]

\[\begin{equation}\label{eq3} \boldsymbol{t}_i = \frac{(\dot{\boldsymbol{p}}_i +\Delta\dot{\boldsymbol{t}}_i)}{\gamma} + \boldsymbol{p}_c,\end{equation}\]

其中，可见点\(\dot{\boldsymbol{p}}_i\)的偏移量分布在一个特定的球体中。与直接对物体平移进行回归相比，这个回归函数得到的输出空间更小。

3D rotationregression：我们按照DenseFusion和PoseCNN的方法，采用四元数来表示旋转。我们得到旋转矩阵的方式如下：

\[\begin{equation}\label{eq4} R_i = Quaternion\_matrix(Norm(\mathcal{B}_Q(\boldsymbol{f}_i))),\end{equation}\]

\[\begin{equation}\label{eq5} Norm(\boldsymbol{q}) =\frac{\boldsymbol{q}_i}{\Vert\boldsymbol{q}_i\Vert},\end{equation}\]

其中，\(Quaternion\_matrix(\cdot)\)表示将四元数转换为旋转矩阵的函数（ASurvey on the Computation of Quaternions from Rotation Matrices）。

Confidenceregression：为了确定最佳的回归结果，我们设置了一个置信度估计头来评估每个特征的置信度\(c_i\)。其公式如下：

\[\begin{equation}\label{eq6} c_i = Sigmoid(\mathcal{B}_C(\boldsymbol{f}_i)),\end{equation}\]

我们采用DenseFusion中提到的自监督方法来训练置信度分支\(\mathcal{B}_C\)。

3.4. Symmetry-aware loss

现有的对称不变距离度量方法依赖于物体的三维形状，例如ADD-S、ACPD、MCPD、VSD（来自“OnEvaluation of 6D Object PoseEstimation”和“DenseFusion”）。然而，独特的形状和点对不匹配是导致错误最小值的原因。此外，在现实中，物体具有各种各样的形状，我们无法保证这些度量方法对每种形状都有效。因此，我们设计了分组基元（GP），将同一类别的物体抽象为几个点，以避免由形状引起的不确定性。此外，我们将这些点分成若干组，并根据公式\(\eqref{eq12}\)和\(\eqref{eq13}\)计算同一组中最近点之间的距离，这就避免了点对不匹配的问题。

Groupedprimitives：我们在图3中展示了分组基元（GP）构建的流程。有了特定物体的三维模型后，我们可以根据公式\(\eqref{eq9}\)和\(\eqref{eq10}\)计算出所有的对称轴。用于分组的基元由对称轴的端点和物体质心组成。具体来说，需要以下三个步骤。

Step1：这里定义并解释了对称轴-轴角的基本性质。物体\(O\)绕轴\(\boldsymbol{e} = (e_x, e_y,e_z)\)旋转角度\(\theta\)后外观保持不变，那么轴\(\boldsymbol{e}\)就是物体\(O\)的一条对称轴。轴\(\boldsymbol{e}\)和角度\(\theta\)构成了一个对称轴-轴角\(\boldsymbol{a}\)，其定义如下：

\[\begin{equation}\label{eq7} \boldsymbol{a} = (\boldsymbol{e}, \theta), \quad\Vert\boldsymbol{e}\Vert = 1 \wedge \theta \in \{\frac{2\pi}{i}\}_{i =2}^M.\end{equation}\]

需要注意的是，\(2\pi\)必须是对称角度\(\theta\)的整数倍（Symmetry），并且对称轴-轴角\(\boldsymbol{a}\)的阶数可以定义为：

\[\begin{equation}\label{eq8} |\boldsymbol{a}| = \frac{2\pi}{\theta}(\boldsymbol{a}).\end{equation}\]

对称轴-轴角是一种冗余的表示形式。例如，对于图4中类别2的物体，如金字塔，它有四个对称轴-轴角：\((\boldsymbol{e}, \frac{\pi}{2})\)、\((\boldsymbol{e}, \pi)\)、\((-\boldsymbol{e}, \frac{\pi}{2})\)和\((-\boldsymbol{e}, \pi)\)，其中\(\boldsymbol{e}\)与绿色线条平行。在这种情况下，由于对称轴\(\boldsymbol{e}\)相同，这四个对称轴-轴角对于该物体而言具有相同的含义。由于旋转对称的周期性，这四个对称轴-轴角的角度必定存在最大公约数\(\frac{\pi}{2}\)。需要注意的是，在本研究中仅使用角度为最大公约数的对称轴-轴角，例如\((\boldsymbol{e}, \frac{\pi}{2})\)和\((-\boldsymbol{e}, \frac{\pi}{2})\)。

Step2：在以物体质心为原点的物体坐标系中，可以通过使用以下公式得到物体\(O\)的一组粗略的对称轴-轴角：

\[\begin{equation}\label{eq9} \hat{A}_O = \{\boldsymbol{a}|h(P_O, R(\boldsymbol{a})P_O) <\epsilon\},\end{equation}\]

其中\(h\)是Hausdorff距离，\(P_O\)表示物体模型的顶点，\(R(\mathbf{a})\)是对称轴-轴角\(\mathbf{a}\)对应的旋转矩阵，并且允许的偏差由\(\varepsilon\)界定。然后，基于这些对称轴，应用MeanShiftclustering algorithm（来自“Mean shift: a robust approach toward featurespace analysis”）来简化\(\hat{A}_O\)：

\[\begin{equation}\label{eq10} A_O = Mean\_Shift(\hat{A}_O),\end{equation}\]

此时，\(A_O\)包含了物体\(O\)的所有无冗余的对称轴-轴角，其中\(|A_O|\)是\(A_O\)的大小，且为\(2\)的倍数，因为对称轴-轴角总是成对出现，例如\((\mathbf{e}, \frac{\pi}{2})\)和\((-\mathbf{e},\frac{\pi}{2})\)。此外，可以得到\(A_O\)的一个子集\(AC_{O}\)如下：

\[\begin{equation}\label{eq11} AC_O = \{\boldsymbol{a} | \boldsymbol{a} \in A_O \wedge|\boldsymbol{a}| > \rho\},\end{equation}\]

其中\(\rho\)是松弛阈值。当\(|\boldsymbol{a}| > \rho\)时，我们将\(\boldsymbol{a}\)视为连续的对称轴-轴角，并且当\(\rho\)设置为\(6\)时，涵盖了大多数应用情况，包括实验部分中要评估的所有物体。根据\(A_O\)和\(AC_O\)的大小，对称物体可以分为五类，如图4所示。

Step 3：如图3所示，如果基元\(A\)绕对称轴旋转特定角度后能够与基元\(B\)重合，那么我们就认为基元\(A\)和\(B\)属于同一组。分组后的基元记为\(G = \{g_i\}_{i = 0}^K\)，其中\(K\)是集合\(G\)的大小。分组原则的详细内容见补充材料。

Pose distancemetric：基于分组基元（GP），设计了位姿距离度量A(M)GPD。A(M)GPD包含两个函数，第一个函数是平均分组基元距离（AGPD）：

\[\begin{equation}\label{eq12} AGPD = \text{mean}_{g_i \in G}\ \text{mean}_{p_j \in g_i}\ \min_{p_k\in g_i, k \ne j} \Vert \hat{p}_j - \dot{p}_k \Vert,\end{equation}\]

其中\(\hat{p} = \hat{T}p\)，\(\dot{p} = \dot{T}p\)，\(p \in g(G)\)，并且\(\hat{T}\)，\(\dot{T} \in SE(3)\)。当物体\(O\)属于对称类别\(\{1, 3, 4,5\}\)中的一个或者是非对称物体时，平均分组基元距离（AGPD）用于度量物体\(O\)的两个位姿之间的距离。

第2类与其他类别不同。它只有一对对称轴，且这对对称轴具有有限的阶数。如果将平均分组基元距离（AGPD）用作损失函数，这种特性会在旋转空间中导致错误的最小值，如图1的第二行所示。为了解决这个问题，引入了第二个函数——最大分组基元距离（MGPD）：

\[\begin{equation}\label{eq13} MGPD = \max_{g_i \in G} \max_{p_j \in g_i} \min_{p_k \in g_i, k \nej} \Vert \hat{p}_j - \dot{p}_k \Vert.\end{equation}\]

Loss for regressiontraining：我们回归框架的总损失与DenseFusion中的损失类似，不同之处在于，我们使用A(M)GPD来计算预测值与真实值之间的误差，而不是使用ADD(S)。

3.5. Validation of A(M)GPD

在本小节中，提出了一种数值计算与可视化方法，用于检验A(M)GPD是否满足引言中所述的要求（1）allminima in the loss surface are mapped to the correctposes。为了更清晰地了解A(M)GPD在\(R \inSO(3)\)上的情况，我们首先采用采样技术生成\(N\)个旋转\(RC =\{R_i\}_{i = 1}^N\)，这些旋转在\(R \inSO(3)\)上密集分布。其次，将单位矩阵\(I_{3 \times 3}\)视为真实值，而\(\dot{R} \in RC\)作为预测值。\(I_{3 \times 3}\)与\(\dot{R}\)之间的A(M)GPD可表示为\(\dot{d}\)。

\[\begin{equation}\label{eq14} \dot{d} = \text{A(M)GPD}(I_{3 \times 3}, \dot{R}).\end{equation}\]

然后，我们借助旋转向量\(\boldsymbol{v} =(v_x, v_y, v_z)\)来可视化\(\dot{d}\)，其中向量的方向为旋转轴，长度为旋转角度\(\theta \in [0,\pi]\)。如图4中第二行的图所示，\(\dot{R}\)的坐标为\(\boldsymbol{v}(\dot{R})\)，\(\dot{R}\)的颜色值对应着相应的\(\dot{d}\)（颜色越深表示\(\dot{d}\)越小）。然而，在这些图中很难找到最小值，所以我们通过一个简单的算法进一步模拟梯度下降的过程。该算法的原理是\(\boldsymbol{v}(\dot{R})\)不断地向\(\boldsymbol{v}(\hat{R})\)移动，\(\boldsymbol{v}(\hat{R})\)在\(\boldsymbol{v}(\dot{R})\)的邻域内具有最小的\(\hat{d}\)，并且这个点最终会停在一个局部最小值处。我们对每个\(\boldsymbol{v}(\dot{R})\)都应用这个原理，并且在图4第三行的图中用红色星号标记出找到的最小值。如我们所见，所有的最小值都被映射到了正确的位姿上。其他物体的情况在补充材料中给出。

4. Experiments

5. Limitations

6. Conclusion

Supplementary Material

1. 创建环境：

   1	conda create --name agpose python=3.9

2. 激活环境：

   1	conda activate agpose

3. 安装PyTorch：

   1	pip3 install torch==1.12 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu113

4. 安装其他依赖：

   1 2 3 4 5 6

   pip3 install gorilla-core==0.2.5.3 pip3 install opencv-python git clone https://github.com/Leeiieeo/AG-Pose.git cd AG-Pose/model/pointnet2 python setup.py install

5. Clone mentian/object-deformnet并安装nn_distance，需要使用该仓库中的代码进行数据处理：

   1 2 3

   git clone https://github.com/mentian/object-deformnet.git cd object-deformnet/lib/nn_distance python setup.py install

下载数据集

1. 下载NOCS数据集到数据集文件夹中：

   • http://download.cs.stanford.edu/orion/nocs/camera_composed_depth.zip
   • http://download.cs.stanford.edu/orion/nocs/camera_train.zip
   • http://download.cs.stanford.edu/orion/nocs/camera_val25K.zip
   • http://download.cs.stanford.edu/orion/nocs/gts.zip
   • http://download.cs.stanford.edu/orion/nocs/obj_models.zip
   • http://download.cs.stanford.edu/orion/nocs/real_test.zip
   • http://download.cs.stanford.edu/orion/nocs/real_train.zip

2. 下载JiehongLin/Self-DPDN的分割结果到仓库文件夹中：

   • https://drive.google.com/file/d/1hNmNRr7YRCgg-c_qdvaIzKEd2g4Kac3w/

3. 下载使用mentian/object-deformnet进行数据预处理时用到的数据到仓库文件夹中：

   • https://drive.google.com/file/d/1p72NdY4Bie_sra9U8zoUNI4fTrQZdbnc/

4. 下载运行AG-Pose时使用到的分割结果：

   • http://home.ustc.edu.cn/~llinxiao/segmentation_results.zip

5. 下载NOCS数据集中缺失的物体模型（From: https://github.com/mentian/object-deformnet/issues/3#issuecomment-698858332）到数据集文件夹中：

   • https://drive.google.com/file/d/1rWkxEVJJh_kWIqxudn_i6sJ-hhd0E7TV/

处理数据集

JiehongLin/Self-DPDN

遵循JiehongLin/Self-DPDN的处理方式，首先解压上述文件，并组织如下，注意，data文件夹位于Self-DPDN文件夹下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

data
├── camera -> /data1/dataset/nocs/tanmx/dpdn/camera
│   ├── train
│   └── val
├── camera_full_depths -> /data1/dataset/nocs/tanmx/dpdn/camera_full_depths/
│   ├── train
│   └── val
├── gts -> /data1/dataset/nocs/tanmx/dpdn/gts/
│   ├── real_test
│   └── val
├── mean_shapes.npy
├── obj_models -> /data1/dataset/nocs/tanmx/dpdn/obj_models/
│   ├── real_test
│   ├── real_train
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/dpdn/real/
│   ├── test
│   └── train
└── segmentation_results -> /data1/dataset/nocs/tanmx/dpdn/segmentation_results/
    ├── test_trainedwithMask
    ├── test_trainedwoMask
    └── train_trainedwoMask

21 directories, 1 file

进入obj_models/val/02876657/d3b53f56b4a7b3b3c9f016d57db96408文件夹，其中内容为

1
2

$ ls
bbox.txt  model.mtl  model.obj

查看model.obj文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ cat model.obj
newmtl Material.57774a50243e5d429f3a4ea105ec3930
d 0.5
Tr 0.5
Kd 0.392157 0.584314 0.929412
newmtl Material.90b00bf69165eda831fe702671104217
Tr 0.0
Kd 0.6 0.117647 0.117647
newmtl Material.dc7a3ca9ca091ddbf48733c3a604f557
Tr 0.0
Kd 1.0 1.0 1.0
newmtl Material.b2cdaf4394d1a4f850458878b81c7fa1
Tr 0.0
Kd 0.8 0.6 0.0

解压https://drive.google.com/file/d/1rWkxEVJJh_kWIqxudn_i6sJ-hhd0E7TV/中的文件：

1
2
3
4
5

$ unzip obj_models.zip
$ ls
02876657  obj_models.zip
$ ls 02876657/d3b53f56b4a7b3b3c9f016d57db96408/
bbox.txt  info.txt  model_bad.mtl  model_bad.obj  model.mtl  model.obj

删除原文件夹obj_models/val/02876657/d3b53f56b4a7b3b3c9f016d57db96408中的内容，将02876657/d3b53f56b4a7b3b3c9f016d57db96408文件夹中的内容复制到该文件夹中：

1
2
3
4

$ rm obj_models/val/02876657/d3b53f56b4a7b3b3c9f016d57db96408/*
$ cp 02876657/d3b53f56b4a7b3b3c9f016d57db96408/* obj_models/val/02876657/d3b53f56b4a7b3b3c9f016d57db96408/
$ ls obj_models/val/02876657/d3b53f56b4a7b3b3c9f016d57db96408
bbox.txt  info.txt  model_bad.mtl  model_bad.obj  model.mtl  model.obj

执行：

1

python data_processing.py

执行后目录变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

data
├── camera -> /data1/dataset/nocs/tanmx/dpdn/camera
│   ├── train
│   ├── train_list_all.txt
│   ├── train_list.txt
│   ├── val
│   └── val_list_all.txt
├── camera_full_depths -> /data1/dataset/nocs/tanmx/dpdn/camera_full_depths/
│   ├── train
│   └── val
├── gts -> /data1/dataset/nocs/tanmx/dpdn/gts/
│   ├── real_test
│   └── val
├── mean_shapes.npy
├── obj_models -> /data1/dataset/nocs/tanmx/dpdn/obj_models/
│   ├── real_test
│   ├── real_train
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/dpdn/real/
│   ├── test
│   ├── test_list_all.txt
│   ├── train
│   ├── train_list_all.txt
│   └── train_list.txt
└── segmentation_results -> /data1/dataset/nocs/tanmx/dpdn/segmentation_results
    ├── test_trainedwithMask
    ├── test_trainedwoMask
    └── train_trainedwoMask

21 directories, 7 files

执行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ ls -l data/camera/
total 9712
drwxr-xr-x 27502 tanmx tanmx  577536 Jun 14  2019 train
-rw-rw-r--     1 tanmx tanmx 4675000 Apr 29 11:00 train_list_all.txt
-rw-rw-r--     1 tanmx tanmx 4235159 Apr 29 15:57 train_list.txt
drwxr-xr-x  2502 tanmx tanmx   69632 Jun 14  2019 val
-rw-rw-r--     1 tanmx tanmx  375000 Apr 29 11:00 val_list_all.txt

$ ls -l data/real/
total 228
drwxrwxr-x 8 tanmx tanmx  4096 Nov 13  2018 test
-rw-rw-r-- 1 tanmx tanmx 49572 Apr 29 11:00 test_list_all.txt
drwxrwxr-x 9 tanmx tanmx  4096 Jun 14  2019 train
-rw-rw-r-- 1 tanmx tanmx 82042 Apr 29 11:00 train_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 82042 Apr 29 16:09 train_list.txt

mentian/object-deformnet

遵循mentian/object-deformnet的处理方式，首先解压上述文件，并组织如下，注意，data文件夹位于object-deformnet文件夹下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

data
├── camera -> /data1/dataset/nocs/tanmx/spd/camera/
│   ├── train
│   └── val
├── deformnet_eval -> /data1/dataset/nocs/tanmx/spd/deformnet_eval/
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/spd/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/spd/obj_models/
│   ├── real_test
│   ├── real_train
│   ├── train
│   └── val
├── pose_dataset.py
├── real -> /data1/dataset/nocs/tanmx/spd/real/
│   ├── test
│   └── train
└── shape_dataset.py

19 directories, 2 files

注意，这里也要和替换掉缺失的物体模型。

按顺序执行：

1
2
3

cd preprocess
python shape_data.py
python pose_data.py

执行python shape_data.py后目录变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

data
├── camera -> /data1/dataset/nocs/tanmx/spd/camera/
│   ├── train
│   └── val
├── deformnet_eval -> /data1/dataset/nocs/tanmx/spd/deformnet_eval/
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/spd/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/spd/obj_models/
│   ├── camera_train.pkl
│   ├── camera_val.pkl
│   ├── mug_meta.pkl
│   ├── real_test
│   ├── real_test.pkl
│   ├── real_train
│   ├── real_train.pkl
│   ├── ShapeNetCore_2048.h5
│   ├── ShapeNetCore_4096.h5
│   ├── train
│   └── val
├── pose_dataset.py
├── real -> /data1/dataset/nocs/tanmx/spd/real/
│   ├── test
│   └── train
└── shape_dataset.py

19 directories, 9 files

执行python pose_data.py后目录变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

data
├── camera -> /data1/dataset/nocs/tanmx/spd/camera
│   ├── train
│   ├── train_list_all.txt
│   ├── train_list.txt
│   ├── val
│   ├── val_list_all.txt
│   └── val_list.txt
├── deformnet_eval -> /data1/dataset/nocs/tanmx/spd/deformnet_eval
│   ├── camera
│   ├── mrcnn_results
│   ├── nocs_results
│   └── real
├── gts -> /data1/dataset/nocs/tanmx/spd/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/spd/obj_models/
│   ├── camera_train.pkl
│   ├── camera_val.pkl
│   ├── mug_meta.pkl
│   ├── real_test
│   ├── real_test.pkl
│   ├── real_train
│   ├── real_train.pkl
│   ├── ShapeNetCore_2048.h5
│   ├── ShapeNetCore_4096.h5
│   ├── train
│   └── val
├── pose_dataset.py
├── real -> /data1/dataset/nocs/tanmx/spd/real/
│   ├── test
│   ├── test_list_all.txt
│   ├── test_list.txt
│   ├── train
│   ├── train_list_all.txt
│   └── train_list.txt
└── shape_dataset.py

19 directories, 17 files

执行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

$ ls -l data/camera/
total 9996
drwxr-xr-x 27502 tanmx tanmx  577536 Jun 14  2019 train
-rw-rw-r--     1 tanmx tanmx 4675000 Apr 29 14:00 train_list_all.txt
-rw-rw-r--     1 tanmx tanmx 4235159 Apr 29 18:42 train_list.txt
drwxr-xr-x  2502 tanmx tanmx   69632 Jun 14  2019 val
-rw-rw-r--     1 tanmx tanmx  375000 Apr 29 14:00 val_list_all.txt
-rw-rw-r--     1 tanmx tanmx  288300 Apr 29 19:15 val_list.txt

$ ls -l data/real/
total 280
drwxrwxr-x 8 tanmx tanmx  4096 Nov 13  2018 test
-rw-rw-r-- 1 tanmx tanmx 49572 Apr 29 14:00 test_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 49572 Apr 29 19:21 test_list.txt
drwxrwxr-x 9 tanmx tanmx  4096 Jun 14  2019 train
-rw-rw-r-- 1 tanmx tanmx 82042 Apr 29 14:00 train_list_all.txt
-rw-rw-r-- 1 tanmx tanmx 82042 Apr 29 18:53 train_list.txt

$ ls -l data/obj_models/
total 116060
-rw-rw-r--  1 tanmx tanmx 26695895 Apr 29 11:32 camera_train.pkl
-rw-rw-r--  1 tanmx tanmx  4634293 Apr 29 11:36 camera_val.pkl
-rw-rw-r--  1 tanmx tanmx    23197 Apr 29 11:37 mug_meta.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_test
-rw-rw-r--  1 tanmx tanmx   443600 Apr 29 11:37 real_test.pkl
drwxrwxr-x  2 tanmx tanmx     4096 Sep 27  2019 real_train
-rw-rw-r--  1 tanmx tanmx   443584 Apr 29 11:37 real_train.pkl
-rw-rw-r--  1 tanmx tanmx 28950893 Apr 29 12:21 ShapeNetCore_2048.h5
-rw-rw-r--  1 tanmx tanmx 57618690 Apr 29 11:39 ShapeNetCore_4096.h5
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 train
drwxr-xr-x 12 tanmx tanmx     4096 Sep 27  2019 val

运行代码

需要JiehongLin/Self-DPDN处理后的数据集及其list和mentian/object-deformnet处理后的物体模型pkl，组织如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

data
├── camera -> /data1/dataset/nocs/tanmx/agpose/camera
│   ├── train
│   ├── train_list_all.txt
│   ├── train_list.txt
│   ├── val
│   └── val_list_all.txt
├── camera_full_depths -> /data1/dataset/nocs/tanmx/agpose/camera_full_depths/
│   ├── train
│   └── val
├── gts -> /data1/dataset/nocs/tanmx/agpose/gts/
│   ├── real_test
│   └── val
├── obj_models -> /data1/dataset/nocs/tanmx/agpose/obj_models/
│   ├── camera_train.pkl
│   ├── real_test
│   ├── real_train
│   ├── real_train.pkl
│   ├── train
│   └── val
├── real -> /data1/dataset/nocs/tanmx/agpose/real/
│   ├── test
│   ├── test_list_all.txt
│   ├── train
│   ├── train_list_all.txt
│   └── train_list.txt
└── segmentation_results -> /data1/dataset/nocs/tanmx/agpose/segmentation_results
    ├── CAMERA25
    └── REAL275

20 directories, 8 files

之后按照仓库README中的命令运行代码即可。

• CPU：1 核心处理器
• 内存：512 MB RAM
• 存储：5 GB
• 端口映射：计算型端口映射（映射规则详见群组和帮助中心）
• 带宽：500M/500Mbps ，1T（双向计费，合理使用）

购买链接：Suda速达云- 香港HKT区NAT 一号机 (04:00定时刷新IP)

2025-04-21测试

ITDOG

https://www.itdog.cn/ping/：

结果图：ITDOG：1.36.*.*

IPQuality

xykt/IPQuality：

1

bash <(curl -Ls IP.Check.Place)

融合怪

spiritLHLS/ecs：

1

curl -L https://gitlab.com/spiritysdx/za/-/raw/main/ecs.sh -o ecs.sh && chmod +x ecs.sh && bash ecs.sh -m 1

https://paste.spiritlhl.net/#/show/nabhD.txt

• 2025.04.06：使用patch-patch的匹配来确定与查询最接近的模板并得到2D-3D的匹配，然后使用EPnP计算粗略位姿。在优化时，将查询和模板之间的flow定义为一个单变量拉普拉斯分布，预测这个分布以优化位姿。

Abstract

1. Introduction

Our contributions can be summarized as follows:

• We present Co-op, a novel framework for unseen object poseestimation in RGB-only cases. Co-op does not require additional trainingor fine-tuning for new objects and outperforms existing methods by alarge margin on the seven core datasets of the BOP Challenge.
• We propose a method for fast and accurate coarse pose estimationusing a hybrid representation that combines patch-level classificationand offset regression.
• Additionally, we propose a precise object pose refinement method. Itestimates dense correspondences defined by probabilistic flow and learnsconfidence end-to-end through a differentiable PnP layer.

2. Related Work

3. Method

3.1. Coarse Pose Estimation

TemplateGeneration：粗略位姿估计阶段使用和GigaPose类似的方法，生成仅包含面外旋转的模板来减少位姿估计需要的模板数。

使用“Templates for 3D Object Pose Estimation Revisited:Generalization to New Objects and Robustness to Occlusions”和“CNOS: AStrong Baseline for CAD-based Novel ObjectSegmentation”中的方法生成模板。

HybridRepresentation：Query图像和Template图像分别使用\(\mathcal{I}_Q, \mathcal{I}_T \in \mathbb{R}^{H\times W \times3}\)表示。为了提高泛化性，使用了一种结合patch分类和偏移回归的混合表示。

图3左侧是patch分类结果，右侧是偏移回归结果。

如图2所示，使用TransformerEncoder提取Query图像和Template图像的特征，然后使用TransformerDecoder生成patch分类结果和偏移回归结果。

Encoder将\(\mathcal{I}_Q\)和\(\mathcal{I}_T\)作为输入，提取特征图\(\mathcal{F}_Q, \mathcal{F}_T \in\mathbb{R}^{\frac{H}{16} \times \frac{W}{16} \times1024}\)。然后Decoder和后续头处理\(\mathcal{F}_Q\)和\(\mathcal{F}_T\)，计算patch级分类\(\mathcal{C} \in \mathbb{R}^{\frac{H}{16} \times\frac{W}{16} \times K}\)和xy-offsets \(\mathcal{U} \in \mathbb{R}^{\frac{H}{16} \times\frac{W}{16} \times 2}\)。

其中，\(K = \frac{H}{16} \times\frac{W}{16} + 1\)表示patch级分类的类数，\(\frac{H}{16} \times\frac{W}{16}\)为patch的数量，最后的\(+1\)表示没有匹配的情况，例如遮挡。对于特征图中的每个位置\((i, j)\)，\(\mathcal{C}_{i, j} \in\mathbb{R}^K\)包含分类分数，指示Query \((i, j)\)位置上的patch和Template中\(\frac{H}{16} \times\frac{W}{16}\)个patch的匹配情况。

在此之后，我们将索引定义为\(c_{i, j} = \arg\max_{k \in 1, 2, \cdots, K} \mathcal{C}_{i,j}^k\)，将偏移的范围定义在\(\mathcal{U}_{i, j} \in [-0.5,0.5]\)。在\(c_{i, j} \neK\)的位置\((i,j)\)上，可以使用下面的公式来计算Query中下标为\((i, j)\)的patch的中心点在Templatepatch中的对应点\(\mathcal{M}_{i,j}^T\)：

\[\begin{equation}\label{eq1} \mathcal{M}_{i, j}^T = \left(\begin{bmatrix} c_{i, j} \mod 16 + 0.5 \\ \lfloor \frac{c_{i, j}}{16} \rfloor + 0.5 \end{bmatrix} + \mathcal{U}_{i, j}\right) \times 16.\end{equation}\]

添加\(\mathcal{U}_{i,j}\)可优化特征图网格中的位置。乘16会将该位置映射回原始图像\(\mathcal{I}_Q\)和\(\mathcal{I}_T\)的坐标系，因为特征图中的每个位置都对应原始图像中一个大小为\(16 \times16\)的patch。对应的Query图像位置\(\mathcal{M}_{i, j}^Q\)为\(((i + 0.5) \times 16, (j + 0.5) \times16)\)，即每个Query patch的中心位置。\(\mathcal{I}_Q\)和\(\mathcal{I}_T\)的对应关系定义为\(\mathcal{M}_{i, j} = (\mathcal{M}_{i, j}^Q,\mathcal{M}_{i, j}^T)\)。

Pose Fitting：我们计算\(\mathcal{I}_Q\)和所有\(\mathcal{I}_T\)的对应关系\(\mathcal{M}\)，并选择与Query最相似的模板\(k\)。每个模板的相似性得分定义如下：

\[\begin{equation}\label{eq2} S_t = \sum_{i, j} \begin{cases} \max(\mathcal{C}_{i, j}), & \text{if } c_{i, j} \ne K \\ 0, & \text{otherwise} \end{cases}.\end{equation}\]

如果\(c_{i, j} =K\)（表示遮挡或不匹配的patch），我们从总和中排除\(\max(\mathcal{C}_{i,j})\)。通过计算每个模板的\(S_t\)，我们选择相似度得分最高的模板作为\(\mathcal{I}_Q\)的最佳匹配，然后基于模板中的深度信息构建2D-3D的对应关系，然后使用RANSAC和EPnP来计算初始位姿。

3.2. Pose Refinement

如图2所示，细化模型就是在粗略位姿估计模型的基础上增加一个密集预测Transformer（DPT）。DPT支持像素级预测，从而实现精确的位姿优化。此外，使用渲染-比较方法迭代优化位姿，该阶段克服了在粗略位姿估计阶段使用预渲染模板所带来的限制，比如自遮挡。

Probabilistic Flow Regression：与“Perspective FlowAggregation for Data-Limited 6D Object Pose Estimation”和“GenFlow:Generalizable Recurrent Flow for 6D Pose Refinement of NovelObjects”类似，细化模型估计Query \(\mathcal{I}_T\)和Render \(\mathcal{I}_R\)之间的流动以优化位姿。要从流中准确恢复位姿，必须防止不准确的流显著影响位姿计算。所以，“PerspectiveFlow Aggregation for Data-Limited 6D Object PoseEstimation”使用RANSAC从位姿估计中概率的排除不准确的流。但是，由于RANSAC对异常值分布敏感，因此当异常值普遍存在或分布不均匀时，RANSAC的性能会下降。

与之前基于流的细化方法不同，我们的目标是学习流的条件概率。根据“ASpanFormer:Detector-Free Image Matching with Adaptive Span Transformer”和“PDC-Net+:Enhanced Probabilistic Dense CorrespondenceNetwork”，我们将这个条件概率定义为\(p(Y |\mathcal{I}_Q, \mathcal{I}_R; \theta)\)，其中\(Y\)是\(\mathcal{I}_Q\)和\(\mathcal{I}_R\)之间的流，\(\theta\)是模型参数。很多方法通过学习预测\(Y\)的方差来实现这一点，并且使用高斯分布或拉普拉斯分布对预测密度进行建模。我们将其建模为单变量拉普拉斯分布以简化问题。具体来说，\(p(Y | \mathcal{I}_Q, \mathcal{I}_R;\theta)\)建模为均值为\(\mu \in\mathbb{R}^{H \times W \times 2}\)，尺度为\(b \in \mathbb{R}^{H \times W \times1}\)的拉普拉斯分布，两者均由网络预测。将流估计表示为概率回归，使我们的模型通过调整尺度参数\(b\)专注于高度可靠的对应关系。

FlowConfidence：要使用模型估计的流来计算位姿，我们需要置信度\(\mathcal{W} \in \mathbb{R}^{H \times W \times1}\)。\(\mathcal{W}\)决定了在计算可微分PnP层中的位姿时，每个流误差的权重。\(\mathcal{W}\)是根据确定性、敏感性和流概率计算得出的，这些概率是通过不同的损失函数学习的。确定性估计从\(\mathcal{I}_R\)到\(\mathcal{I}_Q\)的流是否被遮挡。灵敏度是从位姿损失中学习的，并高亮具有丰富纹理或物体边缘的区域。与“PDC-Net+:Enhanced Probabilistic Dense CorrespondenceNetwork”类似，我们定义了流概率\(P_R\)，它表示真实流动\(y\)位于平均光流\(\mu\)、半径为\(R\)范围内的概率。其计算方式如下：

\[\begin{equation}\label{eq3} P_R = P(\Vert y - \mu\Vert_1 < R) = 1 -\exp\left(-\frac{R}{b}\right).\end{equation}\]

\(P_R\)是可靠性的可解释度量，表示阈值为\(R\)的流的准确性。流置信度\(\mathcal{W}\)计算为确定性、敏感性和\(P_R\)的元素乘积。这意味着在没有遮挡（高质量）、有判别信息可用于解决位姿（高灵敏度）以及准确性（高\(P_R\)）时，\(\mathcal{W}\)将具有更高的值。

Pose Update：为了使用流\(Y\)和流置信度\(\mathcal{W}\)计算细化后的6D位姿\(\mathbf{P}_\text{refined}\)，我们使用基于Levenberg-Marquardt(LM)的PnP求解器。给定输入位姿\(\mathbf{P}_\text{input} = [\mathbf{R}_\text{input}| \mathbf{t}_\text{input}]\)，相机内参矩阵\(\mathbf{K}\)和对应于\(\mathcal{I}_R\)的深度图\(\mathcal{D}_R\)，我们计算\(\mathcal{I}_R\)对应的3D空间坐标\(\mathbf{x}_{u,v}^\text{3D}\)，如下所示：

\[\begin{equation}\label{eq4} \mathbf{x}_{u, v}^\text{3D} =\mathbf{R}_\text{input}^{-1}(\mathbf{K}^{-1}\mathcal{D}_R(u,v)\mathbf{x}_{u, v}^\text{2D} - \mathbf{t}_\text{input}),\end{equation}\]

其中\((u, v)\)是\(\mathcal{I}_R\)中的像素坐标，\(\mathcal{D}_R(u,v)\)是每个像素的深度值，且\(\mathbf{x}_{u, v}^\text{2D} = (u, v,1)^T\)。我们通过最小化加权重投影误差的平方和来优化6D位姿，如下所示：

\[\begin{equation}\label{eq5} \underset{\mathbf{R},\mathbf{t}}{\arg\min}\frac{1}{2}\sum_u\sum_v\Vert\mathcal{W}(u, v)\times (\pi(\mathbf{R}\mathbf{x}_{u, v}^\text{3D} + \mathbf{t}) - ((u,v)^T + Y(u, v)))\Vert^2.\end{equation}\]

其中，\(\pi\)是重投影函数，它使用相机内参\(\mathbf{K}\)将相机坐标中的3D点映射到2D图像点。

根据之前的工作“GenFlow: Generalizable Recurrent Flow for 6D PoseRefinement of NovelObjects”，我们使用LM算法分三次迭代更新位姿，并使用Gauss-Newton算法进一步将其细化为最终位姿。

3.3. Pose Selection

在粗略位姿估计阶段，最佳评分模板可能无法提供用于细化的最佳初始位姿。例如，选择相对于GT旋转180度的模板（见图4）会使优化变得具有挑战性。

为了解决这个问题，“MegaPose”、“GenFlow”、“GigaPose”、“FoundPose”、“FoundationPose”等方法采用多重假设策略：生成\(N\)个粗略位姿估计，细化每个估计，并通过将渲染的结果和查询图像进行比较来选择最佳匹配。我们的位姿选择模型以查询图像和模板作为输入，在粗略位姿估计模型的基础上增加一个评分头来对每个位姿假设进行评分。即使这会增加推理时间，但是考虑多个优化位姿能够避免难以优化模板导致最终位姿较差的情况。

3.4. Training

Datasets：为了训练我们的三个模型（粗略位姿估计器、位姿优化器和位姿选择器），我们需要具有GT6D位姿标注的RGBD图像。我们使用“MegaPose: 6D Pose Estimation of NovelObjects via Render &Compare”提供的大规模数据集。该数据集由使用“BlenderProc2: A ProceduralPipeline for PhotorealisticRendering”生成的合成数据组成，其中包含来自“ShapeNet: An Information-Rich3D Model Repository”和“Google Scanned Objects: A High-Quality Dataset of3D Scanned Household Items”的各种对象，包括全面的GT6D位姿标注和对象掩码。

CoarseModel：我们的粗略位姿估计模型经过训练，用于估计查询图像\(\mathcal{I}_Q\)和模板图像\(\mathcal{I}_T\)之间的对应关系。和“GigaPose:Fast and Robust Novel Object Pose Estimation via OneCorrespondence”相似，我们选取的模板与围绕目标物体裁剪出的训练图像相比，具有相似的面外旋转角度，但面内旋转角度不同。如图5所示，我们的模型旨在估计查询图像和模板之间对于面内旋转具有不变性的对应关系。这种不变性意味着这些模板只需考虑面外旋转情况，从而大幅减少了所需模板的数量。由于我们拥有目标物体的3D模型，我们可以通过将3D模型投影到查询图像和模板图像的图像平面上，来生成这些对应关系。我们的模型经过训练就是为了估计这些生成的2D-2D的对应关系。

RefinerModel：我们的优化模型的训练方式与之前采用“渲染-比较”方法的研究工作如“CosyPose”、“MegaPose”、“GenFlow”等类似。我们通过向真实位姿\(\mathbf{P}_\text{gt}\)添加均值为0的高斯噪声来生成含噪声的输入位姿\(\mathbf{P}_\text{input}\)，其中沿\(x\)、\(y\)、\(z\)轴的平移噪声标准差分别为\((0.01, 0.01,0.05)\)，并且在欧拉角中每个轴的旋转噪声标准差为15度。该模型经过训练，能够从\(\mathbf{P}_\text{input}\)中预测出\(\mathbf{P}_\text{gt}\)。

SelectionModel：我们的选择模型经过训练，能够基于含噪输入姿态\(\mathbf{P}_\text{input}\)来评估查询图像\(\mathcal{I}_Q\)与参考图像\(\mathcal{I}_R\)之间的相似度，以便从多个姿态假设中选出最准确的姿态。我们使用二元交叉熵损失函数来训练该模型，对于每个真实姿态\(\mathbf{P}_\text{gt}\)，使用六个姿态：一个正样本，五个负样本。正样本与真实姿态\(\mathbf{P}_\text{gt}\)之间的平移差异在\((0.01, 0.01,0.05)\)范围内，旋转差异在5度以内。通过为正样本设置较小的旋转阈值，我们增强了模型区分与真实姿态相近的姿态的能力，从而提高了其判别能力。

3.5. Implementation Details

Co-op的编码器和解码器架构基于“CroCo v2: Improved Cross-viewCompletion Pre-training for Stereo Matching and OpticalFlow”，这是一个在大规模数据集上针对三维视觉任务训练的视觉基础模型。这使我们能够充分利用CroCov2预训练的优势。粗略位姿估计模型处理分辨率为\(224 \times224\)的输入图像，而优化模型和选择模型则处理分辨率为\(256 \times256\)的图像。有关模型配置、学习率和训练计划的详细信息，请参考补充材料。

CoarseModel：在我们的粗略估计模型中，我们将半密集对应关系定义为一种混合表示，它结合了补丁级别的分类和偏移回归。因此，粗略估计模型使用两个损失函数进行训练：分类损失\(\mathcal{L}_{cls}\)和回归损失\(\mathcal{L}_{reg}\)。

当把从查询图像中patch中心\((i,j)\)到模板的真实匹配定义为\(\mathcal{M}_{gt}^T=(\bar{u},\bar{v})\)时，若存在匹配情况，用于\(\mathcal{L}_{cls}\)的真实索引被定义为\(\frac{\bar{v}}{16} \times \frac{W}{16} +\frac{\bar{u}}{16}\)。此处，\(\mathcal{W}\)是模板图像的宽度，除以\(16\)是考虑到因patch大小而导致的图像尺寸缩小。当不存在匹配时，真实索引被定义为\(\frac{H}{16} \times \frac{W}{16} +1\)，它代表着一个额外的“无匹配”类别。因此，\(\mathcal{L}_{cls}\)被定义为真实索引与模型输出的patch级别概率向量之间的交叉熵损失。

用于\(\mathcal{L}_{reg}\)的偏移真实值\(\mathcal{U}_{gt}\)定义如下：

\[\begin{equation}\label{eq6} \mathcal{U}_{gt} = \frac{\mathcal{M}_{gt}^T}{16} -\left\lfloor\frac{\mathcal{M}_{gt}^T}{16}\right\rfloor - 0.5,\end{equation}\]

其中\(\mathcal{M}_{gt}^T\)是模板中的真实匹配。减去\(\left\lfloor\frac{\mathcal{M}_{gt}^T}{16}\right\rfloor\)再减去\(0.5\)可将偏移量以patch为中心，其范围在\(-0.5\)到\(0.5\)之间。这里，\(\mathcal{U}\)表示模型输出的预测偏移量。然后，回归损失\(\mathcal{L}_{reg}\)被定义为\(\mathcal{U}\)和\(\mathcal{U}_{gt}\)之间的L1损失：

\[\begin{equation}\label{eq7} \mathcal{L}_\text{reg} = \Vert \mathcal{U} - \mathcal{U}_{gt}\Vert_1.\end{equation}\]

因此，用于训练粗略模型的总损失\(\mathcal{L}_\text{coarse}\)定义为：

\[\begin{equation}\label{eq8} \mathcal{L}_\text{coarse} = \mathcal{L}_\text{cls} +\alpha\mathcal{L}_\text{reg}.\end{equation}\]

在上面的等式中，\(\alpha\)设置为2。

RefinerModel：我们的优化模型的训练使用了光流损失、确定性损失和姿态损失，这与“GenFlow”的方法类似。由于我们用拉普拉斯分布对网络的光流输出进行参数化，所以我们通过最小化负对数似然来训练光流。因此，光流损失定义如下：

\[\begin{equation}\label{eq9} \mathcal{L}_{flow} = \sum_u\sum_v\left[\frac{|\mu_{u, v} -\bar{\mu}_{u, v}|}{b_{u, v}} + 2\log b_{u, v}\right].\end{equation}\]

在这个公式中，\(\mu_{u,v}\)是渲染掩码内像素位置\((u, v)\)处的光流，\(\bar{\mu}_{u,v}\)是真实光流。\(b_{u,v}\)是像素位置\((u,v)\)处的尺度（不确定性）。此外，确定性损失\(\mathcal{L}_{cert}\)被定义为二元交叉熵损失，用于判断从渲染图像\(\mathcal{I}_R\)到查询图像\(\mathcal{I}_Q\)的光流是否落在\(\mathcal{I}_Q\)的真实掩码内。姿态损失\(\mathcal{L}_{pose}\)用于量化优化后的姿态与真实姿态之间的差异，按照先前在“MegaPose”和“GenFlow”中使用的方法，它被定义为3D模型上对应3D点之间的距离。关于\(\mathcal{L}_{pose}\)的详细信息在补充材料中给出。

优化模型的总体损失定义如下：

\[\begin{equation}\label{eq10} \mathcal{L}_{refiner} = \mathcal{L}_{flow} + \beta\mathcal{L}_{cert}+ \gamma\mathcal{L}_{pose}.\end{equation}\]

每个损失的权重\(\beta\)和\(\gamma\)分别设置为5和20。

4. Experiments

4.1. Experimental Setup

4.2. BOP Benchmark Results

4.2.1 Coarse Estimation

4.2.2 Pose Refinement

4.3. Ablation Study

5. Conclusion

Supplementary Material

6. Training Details

7. Additional Experiments

8. Qualitative Results

• 2025.04.05：任意物体方法，输入一张锚点图\(I_A\)和一张查询图\(I_Q\)，估计锚点图到查询图的相对位姿。首先基于锚点图，用图生3D模型来生成3D模型\(O_N\)，然后将\(O_N\)与\(I_A\)对齐，对齐的过程会得到变换\(\mathbf{T}_a \in\text{SE}(3)\)和物体大小\(s \in\mathbb{R}^3\)，使用这两个变换能将\(O_N\)变换为\(O_{M^\prime}\)。\(O_{M^\prime}\)会再次进行优化得到\(O_M\)和\(\mathbf{T}_{O_M \to A}\)，然后基于\(O_M\)和\(I_Q\)，使用渲染-比较的方法，得到\(\mathbf{T}_{O_M \to Q}\)。结合\(\mathbf{T}_{O_M \to A}\)和\(\mathbf{T}_{O_M \to Q}\)，得到\(\mathbf{T}_{A \to Q}\)。

Abstract

1. Introduction

The main contributions of our work are as follows:

• We introduce Any6DPose, a novel framework that enables 6D pose andsize estimation of novel objects in different scenes from only a singlereference image.
• We propose a straightforward yet effective object alignmenttechnique that addresses the challenges of existing 3D generationmodels, specifically improving 2D-3D alignment and size estimation foraccurate pose estimation.
• We validate our approach through extensive experiments,demonstrating superior performance compared to state-of-the-art methodsacross five benchmark datasets.

2. Related Works

3. Method

给定锚点RGBD图像\(I_A\)和查询RGBD图像\(I_Q\)，我们的任务是估计出这两张图像之间的相对位姿。查询图像可能在和锚点图像完全不同的视角和场景下捕获同一对象。我们的任务是估计出\(I_A\)和\(I_Q\)之间的相对位姿\(\mathbf{T}_{A \to Q} \in\text{SE}(3)\)，其中\(\mathbf{T}_{A \toQ}\)定义为一个刚体变换\([R |t]\)，包含一个旋转\(R \in\text{SO}(3)\)和平移\(t \in\mathbb{R}^3\)。

在先前的方法中，一部分方法使用可见部分匹配来估计两个视角之间同一物体的相对位姿，这些方法在视角之间的重叠较大时有效，但在视角变化较大时性能较差；另一部分方法通过重建3D模型来实现完全到部分的匹配。

提出的Any6D可以估计锚点图像\(I_A\)和查询图像\(I_Q\)之间的相对位姿\(\mathbf{T}_{A \toQ}\)，方法包括两个部分：

1. 首先使用image-to-3D模型，在不考虑真实世界的比例和位姿的前提下，从锚点图像重建归一化物体模型\(O_N\)，然后通过确定实际对象大小\(s \in \mathbb{R}^3\)和位姿\(\mathbf{T}_{O_M \toA}\)来估计度量尺度物体模型\(O_M\)，并将其在二维和三维空间中进行精确对齐；
2. 接下来，我们利用重建的度量尺度物体模型\(O_M\)和查询图像\(I_Q\)进行姿态估计，通过融合\(\mathbf{T}_{O_M \to A}\)和\(\mathbf{T}_{O_M \to Q}\)推到出相对变换\(\mathbf{T}_{A \toQ}\)。Any6D框架的完整工作流程如图2所示。

3.1. Coarse Object Alignment

据我们所知，现阶段还没有可靠的RGBD单视角度量尺度重建方案可以有效的处理各种对象。所以这里使用“InstantMesh:Efficient 3D Mesh Generation from a Single Image with Sparse-view LargeReconstructionModels”。然而，一个关键的限制在于，3D物体重建只能生成具有归一化尺度的物体模型\(O_N\)（XYZ轴的范围都是\([-1,1]\)），这意味着重建的模型未针对实际场景进行正确的尺寸缩放或空间定位。所以我们进行了物体对齐：首先估计物体形状\(O_M\)的粗略尺寸，然后通过联合求解\(\mathbf{T}_{O_M \toA}\)来优化该尺寸。我们的方法涉及在锚点图像\(I_A\)与归一化形状\(O_N\)之间进行3D和2D的物体模型对齐，具体包括变换\(\mathbf{T}_a \in \text{SE}(3)\)和尺寸\(s \in \mathbb{R}^3\)。

具体来说，我们基于\(I_A\)，使用由粗到细的方法来估计物体尺寸\(s\)。首先通过比较\(I_A\)和\(O_N\)之间来自各自物体中心的点云来初始化粗略对象大小。虽然可以使用点的均值来直接估计中心，但是由于锚点图像中的部分视角问题和锚点图像中存在离群点，这种直接估计的方法是不可靠的。如图3(a)和图3(b)所示。

因为锚点图像中物体的部分可见性，使用简单的boundingbox轴对齐方法同样也会导致不准确，如图3(c)所示。因此，我们提出使用有向边界框来确定物体中心，如图3(d)所示，这为\(I_A\)提供了更可靠的粗略中心估计。对于轴对齐，我们将有向边界框与XYZ轴对齐，对不同的旋转角度进行采样，然后计算\(I_A\)和\(O_N\)在不同角度旋转后boundingbox之间的IoU。能够使IoU最大的旋转和缩放组合会把\(O_N\)变换为粗略对齐的物体模型，并将其更新为初始物体模型\(O_{M^\prime}\)，随后\(O_{M^\prime}\)将被用于精确的位姿和尺寸估计。

3.2. Fine Object Alignment

方法首先重建粗略物体模型\(O_{M^\prime}\)，然后通过物体和大小联合优化来优化位姿和物体大小。

优化部分的灵感来自“FoundationPose: Unified 6D Pose Estimation andTracking of NovelObjects”，但是FoundationPose需要物体的CAD模型，在没有物体CAD模型的情况下，则需要多张有位姿标注的参考图像。因此，我们开发了一个联合模块，将大小估计任务融入到位姿优化过程中。这使我们能够可靠地同时估计大小和位姿。

优化流程主要包括三个主要模块：位姿估计、大小估计和轴对齐，这些模块在一个统一的过程中协同工作，通过在大小优化和位姿优化这两项任务之间交替进行来实现。我们首先使用\(O_{M^\prime}\)来估计初始位姿，同时优化物体大小。在FoundationPose中，采样生成位姿假设的过程只在\(\text{SO}(3)\)中进行，而没有考虑大小的变化。与FoundationPose不同的是，我们的方法除了在\(\text{SO}(3)\)中采样，还额外采样了不同的大小。具体来说，大小采样在每个轴上的范围为\(\Delta s \in [s_0, s_1]\)（其中\(s_0 = 0.6, s_1 =1.4\)）。然后我们使用FoundationPose中的模块来优化位姿假设，并将优化后的位姿进行渲染，以与查询图像比较。最优位姿的选择会基于FoundationPose中位姿选择模块给出的比较分数进行选择。当最优大小确定时，我们会将物体大小进行缩放，并进入到位姿优化阶段，包括一个轴对齐步骤，以实现更高的精度。这种更新后的对齐方式利用了大小和位姿的联合估计，比传统的基于IoU的方法具有更高的精度。

在优化了物体参数之后，我们确定最终的物体位姿\(T_{O_M \toA}\)，它能为重建的物体模型提供精确的对齐。利用锚点图像\(I_A\)，查询图像\(I_Q\)和重建的物体模型\(O_M\)，我们通过组合两个变换来估计相对位姿\(\mathbf{T}_{A \toQ}\)：从物体模型到锚点图像的变换\(\mathbf{T}_{O_M \toA}\)和从物体模型到查询图像的变换\(\mathbf{T}_{O_M \toQ}\)。相对位姿可以表示如下：

\[\begin{equation}\label{eq1} \mathbf{T}_{A \to Q} = (\mathbf{T}_{O_M \to A})^{-1} \cdot\mathbf{T}_{O_M \to Q}\end{equation}\]

对于位姿选择，我们采用一个两阶段的渲染-比较策略。首先，一个位姿排序网络会通过比较渲染结果和裁剪后的观测图像来评估每个假设，得到一个嵌入向量以量化对齐质量。然后，我们对所有位姿假设的拼接嵌入向量应用自注意力机制，融入全局上下文信息，从而生成最终分数，以便选出最优位姿。

4. Experiments

4.1. Datasets

4.2. Metrics

4.3. Comparison withState-of-the-art

4.4. Qualitative Results

4.5. Ablation Studies

5. Conclusion

• 2025.04.01：类别级方法，使用一个网络估计旋转，另一个网络估计平移和缩放，24年CVPRSecondPose沿用了这个方法，对于旋转，该方法将旋转估计分为视角旋转和面内旋转，视作一个分类任务，分别估计，最后组合；对于平移和缩放，该方法使用PointNet++提取特征，直接估计平移和旋转

Abstract

1. Introduction

2. Related Work

3.Correlation on the Sphere and Rotation Decomposition

如图1所示，使用\(\mathbf{R}^T\)将物体坐标系XYZ与相机坐标系X'Y'Z'对齐（假设物体坐标系的XYZ的原点和相机坐标系的X'Y'Z'的原点重合），这个过程可以分为两步：

1. 第一步是将Z'轴与Z轴对齐，这一步由旋转矩阵\(\mathbf{R}_{vp}^T\)实现，“vp”代表的是“viewpoint”，即视角；
2. 第二步是将X'轴和Y'轴旋转到X轴和Y轴，这一步由旋转矩阵\(\mathbf{R}_{ip}^T\)实现，“ip”代表的是“in-plane”，即平面内。

那么将物体坐标系XYZ与相机坐标系X'Y'Z'对齐的过程可以表示为：\(\mathbf{R}^T =\mathbf{R}_{ip}^T\mathbf{R}_{vp}^T\)。

由于在\(SO(3)\)中，矩阵的转置就是矩阵的逆，那么将物体坐标系XYZ和相机坐标系X'Y'Z'恢复到原来的相对位置的过程可以表示为：

\[\begin{equation}\label{eq1} \mathbf{R} = \mathbf{R}_{vp}\mathbf{R}_{ip},\end{equation}\]

现在从物体坐标系XYZ和相机坐标系X'Y'Z'对齐时的状态出发，假设在物体坐标系Z轴上有一点\((0, 0, 1)\)，使用\(\mathbf{R} =\mathbf{R}_{vp}\mathbf{R}_{ip}\)的过程恢复到原来的相对位置，同样也分为两步：

1. 首先使用\(\mathbf{R}_{ip}\)让物体坐标系XYZ旋转绕Z'轴旋转\(\beta \in [0, 2\pi]\)，其旋转矩阵为：

   \[\begin{equation}\label{eq2} \mathbf{R}_{ip} = \begin{bmatrix} \cos\beta & -\sin\beta & 0 \\ \sin\beta & \cos\beta & 0 \\ 0 & 0 & 1 \end{bmatrix}.\end{equation}\]

2. 此时，物体坐标系XYZ与相机坐标系X'Y'Z'不完全重合（Z轴与Z'轴是重合的，但X轴与X'轴、Y轴与Y'轴不重合），先将物体绕着Y'轴旋转\(\theta \in [0, \pi]\)，其旋转矩阵为：

   \[\mathbf{R}_Y(\theta) =\begin{bmatrix} \cos\theta & 0 & \sin\theta \\ 0 & 1 & 0 \\ -\sin\theta & 0 & \cos\theta\end{bmatrix};\]

3. 再将物体绕着Z'轴旋转\(\varphi \in [0,2\pi]\)，其旋转矩阵为：

   \[\mathbf{R}_Z(\varphi) =\begin{bmatrix} \cos\varphi & -\sin\varphi & 0 \\ \sin\varphi & \cos\varphi & 0 \\ 0 & 0 & 1\end{bmatrix};\]

那么结合上面的第2步和第3步，Z轴上的这一点的坐标变为\((v_x, v_y, v_z)\)，那么可以计算\((r, \varphi,\theta)\)为（这里我不理解，我觉得公式是错的）：

\[\begin{equation}\label{eq3} \left\{\begin{matrix} \begin{aligned} r &= 1 \\ \varphi &= \arctan(\frac{v_x}{v_z}) \\ \theta &= \arccos(\frac{v_y}{r}) \end{aligned} \end{matrix}\right.,\end{equation}\]

结合\(\mathbf{R}_Y(\theta)\)和\(\mathbf{R}_Z(\varphi)\)，可以得到：

\[\begin{equation}\label{eq4} \begin{aligned} \mathbf{R}_{vp} &= \mathbf{R}_Z(\varphi)\mathbf{R}_Y(\theta)\\ &= \begin{bmatrix} \cos\varphi & -\sin\varphi & 0 \\ \sin\varphi & \cos\varphi & 0 \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} \cos\theta & 0 & \sin\theta \\ 0 & 1 & 0 \\ -\sin\theta & 0 & \cos\theta \end{bmatrix} \end{aligned}.\end{equation}\]

结合\(\eqref{eq4}\)和\(\eqref{eq2}\)，可以发现\(\mathbf{R} =\mathbf{R}_{vp}\mathbf{R}_{ip}\)与ZYZ欧拉角\(\varphi, \theta, \beta\)的参数化一致。

根据以上推导，估计物体的旋转可以分解为两个步骤：

1. 在球体上搜索点\((v_x, v_y,v_z)\)，以获得\(\varphi\)和\(\theta\)，共同得到视角旋转\(\mathbf{R}_{vp}\)；
2. 通过\(\mathbf{R}_{vp}\)将Z'轴与Z轴对齐，然后回归面内旋转\(\mathbf{R}_{ip}\)。

4. VI-Net for RotationEstimation

4.1. Conversion asSpherical Representations

给定一个点集\(\mathcal{P} \in \mathbb{R}^{N\times 3}\)，每一个点都对应一个特征\(\mathcal{F} \in \mathbb{R}^{N \timesC_0}\)（比如径向距离、RGB值、表面法线等），首先使用“LearningSO(3) Equivariant Representations with Spherical CNNs”和“DualPoseNet:Category-level 6D Object Pose and Size Estimation Using Dual PoseNetwork with Refined Learning of PoseConsistency”中的方法，生成在球体上定义的特征图\(\mathcal{S}_0 \in \mathbb{R}^{C_0 \times H_0\times W_0}\)，其中\(N\)是点的数量，\(H_0 \times W_0\)是球面采样分辨率，\(C_0\)是特征维度（比如\(C_0 = 1\)为径向距离，\(C_0 = 3\)为RGB值或表面法线）。

具体来说，将球面坐标系沿方位轴（水平方向）和倾角轴（竖直方向）均匀的划分为\(H_0 \timesW_0\)个网格（如图3所示），在每一个网格中，我们搜索径向距离最大的点，表示为\(\mathbf{p}_{h, w}^{max}\)，并让\(\mathcal{S}_0(h, w) = \mathbf{f}_{h, w}^{max} \in\mathcal{F}\)，对应于\(\mathbf{p}_{h,w}^{max}\)；如果这个区域内没有点，则让\(\mathcal{S}_0(h, w) = \mathbf{0}\)。

4.2. Spherical FeaturePyramid Network

使用ResNet18构建特征金字塔网络（FPN），用SPAtial SphericalConvolutions (SPA-SConvs)，代替传统的2D卷积，得到高级语义球形特征图\(\mathcal{S} \in \mathbb{R}^{C \times H \timesW}\)，如图2所示。第5部分中会有详细介绍。

4.3. V-Branch

V-Branch估计视角旋转\(\mathbf{R}_{vp}\)，视角旋转中包含了方位角\(\varphi\)和倾角\(\theta\)，为了简化任务，可以分别估计\(\varphi\)和\(\theta\)，这也有效缓解了正负样本对不平衡的问题。图2给出了V-Branch的图示。

以两层MLP提升\(\mathcal{S}\)的特征维度，得到\(\mathcal{S}_{vp} \in \mathbb{R}^{C_{vp} \times H\times W}\)。为了学习水平方位角\(\varphi\)，在竖直方向上的倾角维度对\(S_{vp}\)进行最大池化，得到\(\mathcal{F}_\varphi \in \mathbb{R}^{C_{vp} \timesW}\)，再将其送入另一个MLP中得到\(W\)方位角区域的概率图\(\mathcal{Y}_\alpha \in\mathbb{R}^W\)。\(\mathcal{Y}_\alpha\)中的每一个元素都表示该区域成为目标的可能性。将具有最大概率的元素的索引表示为\(w_{max}\)，则有：

\[\begin{equation}\label{eq5} \varphi = \frac{w_{max} + 0.5}{W} \times 2\pi.\end{equation}\]

同样，对于倾角\(\theta\)，沿水平方向上的方位角维度对\(S_{vp}\)进行最大池化，得到\(\mathcal{F}_\theta \in \mathbb{R}^{C_{vp} \timesH}\)，然后得到\(\mathcal{Y}_\beta \in\mathbb{R}^H\)，那么\(\theta\)可以计算如下：

\[\begin{equation}\label{eq6} \theta = \frac{h_{max} + 0.5}{H} \times \pi.\end{equation}\]

其中\(h_{max}\)是\(\mathcal{Y}_\beta\)中最大概率的索引。最后，结合\(\eqref{eq5}\)、\(\eqref{eq6}\)和\(\eqref{eq4}\)，可以得到视角旋转\(\mathbf{R}_{vp} =\mathbf{R}_Z(\varphi)\mathbf{R}_Y(\theta)\)。

4.4. I-Branch

在V-Branch之后，我们已经得到了视角旋转\(\mathbf{R}_{vp}\)，那么就可以使用\(\mathbf{R}_{vp}\)将Z'轴与Z轴对齐（如图1所示）。对齐后可以构建一个新的球面特征图\(S_{ip} \in \mathbb{R}^{C \times H \timesW}\)。\(\mathcal{S}\)的视点不变性使得在特征空间中实现变换以获得\(S_{ip}\)成为可能。

对于分辨率为\(H \timesW\)的规则球面映射，我们将所有\(HW\)离散锚点的中心点表示为点集\(\mathcal{G} =\{\mathbf{g}\}\)。当我们用\(\mathbf{R}_{vp}\)将点集\(\mathcal{P} = \{\mathbf{p}\}\)旋转到\(\mathcal{P}^\prime = \{\mathbf{p}^\prime\} =\{\mathbf{R}_{vp}^T\mathbf{p}\}\)时，\(\mathcal{S}\)的锚点也旋转为\(\mathcal{G}^\prime = \{\mathbf{g}^\prime\} =\{\mathbf{R}_{vp}^T\mathbf{g}\}\)；我们将\(\mathbf{g}^\prime\)的特征标记为\(\mathcal{S}^{\mathbf{g}^\prime}\)。

为了从顶部观察物体，需要为变换后的\(\mathcal{P}^\prime\)构建一个新的球形特征图\(\mathcal{S}_{ip}\)。对于\(\mathcal{S}_{ip}\)，我们使用“PointNet++:Deep Hierarchical Feature Learning on Point Sets in a MetricSpace”中的点特征加权插值方法，在每个锚点\(\mathbf{g}\)上生成其特征，表示为\(\mathcal{S}_{ip}^\mathbf{g}\)，如下所示：

\[\begin{equation}\label{eq7} \mathcal{S}_{ip}^\mathbf{g} = \frac{\sum_{i = 1}^k a_i\mathcal{S}^{\mathbf{g}^\prime_i}}{\sum_{i = 1}^k a_i},\end{equation}\]

其中\(a_i = \frac{1}{\Vert\mathbf{g} -\mathbf{g}^\prime_i\Vert}\)是按点距离衡量的插值权重，\(\{\mathbf{g}_i^\prime\}_{i = 1}^k \subset\mathcal{G}^\prime\)是\(\mathbf{g}\)的\(k\)个最近邻。

通过\(\eqref{eq7}\)实现从\(\mathcal{S}\)到\(\mathcal{S}_{ip}\)的转换后，使用卷积来降低\(\mathcal{S}_{ip}\)的分辨率，并为\(\mathbf{R}_{ip}\)的回归提取一个全局特征图，如图2所示。旋转的连续6D表示作为回归的输出，然后转换为旋转矩阵\(\mathbf{R}_{ip}\)。这里预测的\(\mathbf{R}_{ip}\)并不只包含面内旋转，而是残差视点旋转和精确面内旋转的组合。

4.5. Training of VI-Net

对于V-Branch，使用来自“Focal Loss for Dense ObjectDetection”的焦点损失，给定GT \(\hat{\mathcal{Y}}_\varphi \in\mathbb{R}^W\)和\(\hat{\mathcal{Y}}_\theta \in\mathbb{R}^H\)，损失函数为：

\[\begin{equation}\label{eq8} \mathcal{L}_{vp} = \mathcal{D}_{FL}(\mathcal{Y}_\varphi,\hat{\mathcal{Y}}_\varphi) + \mathcal{D}_{FL}(\mathcal{Y}_\theta,\hat{\mathcal{Y}}_\theta),\end{equation}\]

其中：

\[\begin{equation}\label{eq9} \mathcal{D}_{FL}(\mathcal{Y}, \hat{\mathcal{Y}}) = \frac{1}{M}\sum_{i = 1}^M -\alpha(1 - t_{i, t})^\gamma \log(y_{i, t}),\end{equation}\]

且：

\[\begin{equation}\label{eq10} y_{i, t} = \begin{cases} y_i, & \text{if} & \hat{y}_i = 1 \\ 1 - y_i, & \text{if} & \hat{y}_i = 0 \end{cases},\end{equation}\]

其中\(\mathcal{Y} = \{y_i\}_{i =1}^M\)，\(\hat{\mathcal{Y}} =\{\hat{y}_i \in \{0, 1\}\}_{i = 1}^M\)。\(\alpha\)是权重因子，\(\gamma\)表示调节因子的指数。

给定GT \(\hat{\mathbf{R}}\)，我们对I-Branch的输出\(\mathbf{R} =\mathbf{R}_{vp}\mathbf{R}_{ip}\)监督如下：

\[\begin{equation}\label{eq11} \mathcal{L}_{ip} = \Vert\mathbf{R} - \hat{\mathbf{R}}\Vert =\Vert\mathbf{R}_{vp}\mathbf{R}_{ip} - \hat{\mathbf{R}}\Vert.\end{equation}\]

结合\(\eqref{eq8}\)和\(\eqref{eq11}\)，VI-Net的训练目标为：

\[\begin{equation}\label{eq12} \min \mathcal{L} = \mathcal{L}_{ip} + \lambda \mathcal{L}_{vp}.\end{equation}\]

其中\(\lambda\)是平衡两个损失的权重因子。

5. Spatial SphericalConvolution

方法建立具有规则2D空间大小的球形特征图以实现旋转估计，特征图建立后，就可以使用传统的2D卷积来处理球形信号。但是，直接在球形特征图上使用2D卷积会有边界问题，比如特征图\(S_0\)上的\(S_0(h,1)\)和\(S_0(h,W)\)在球面上是相连的，而在特征图中则有很大的距离。此外，为了支持I-Branch中的特征转换以便从天顶方向查看，backbone中的卷积也需要是视角一致的。这里提出了SPAtialSphericalConvolution，即SPA-SConv，在球面上连续提取视角一致的特征，可以灵活的适应现有的卷积架构，例如4.2节中的FPN。

给定输入球面特征图\(\mathcal{S}_l \in\mathbb{R}^{C_l \times H_l \timesW_l}\)和卷积参数（如卷积核大小\(K\)、步长\(s\)和输出通道数\(C_{l +1}\)等），我们分两步实现SPA-SConv：

1. 将\(\mathcal{S}_l\)padding到\(S_l^{pad} \in \mathbb{R}^{C_l \times (H_l + 2P)\times (W_l + 2P)}\)，其中\(P = \frac{K- 1}{2}\)；
2. 将对称卷积应用于\(S_l^{pad}\)，基于没有padding的常规2D卷积，得到输出球面特征图\(\mathcal{S}_{l + 1} \in \mathbb{R}^{C_{l + 1}\times H_{l + 1} \times W_{l + 1}}\)，其中\(H_{l + 1} =\lfloor\frac{H_l}{s}\rfloor\)，\(W_{l +1} =\lfloor\frac{W_l}{s}\rfloor\)（为简单起见，我们假设2D卷积核的长度和宽度都是\(K\)，\(K\)是一个奇数）。

图3可视化了从\(\mathcal{S}_l\)到\(S_l^{pad}\)的padding过程。首先，将\(\mathcal{S}_l\)的中心作为\(\mathcal{S}_l^{pad}\)的中心：

\[\begin{equation}\label{eq13} S_l^{pad}(h + P, w + P) = \mathcal{S}_l(h, w),\end{equation}\]

对于\(\forall h = 1, 2, \cdots,H_l\)和\(\forall w = 1, 2, \cdots,W_l\)。接下来，我们沿倾角方向填充\(\mathcal{S}_l\)：

\[\begin{equation}\label{eq14} \begin{aligned} S_l^{pad}(p, w + P) &= \mathcal{S}_l^{pad}(2P - p + 1,w^\prime), \\ \text{and } S_l^{pad}(H_l + P + p, w + P) &=\mathcal{S}_l^{pad}(H_l + P - p + 1, w^\prime), \end{aligned}\end{equation}\]

其中：

\[\begin{equation}\label{eq15} w^\prime = \begin{cases} w + \frac{W_l}{2} + P & \text{if} & w \le \frac{W_l}{2}\\ w - \frac{W_l}{2} + P & & \text{otherwise} \end{cases},\end{equation}\]

对于\(\forall p = 1, 2, \cdots,P\)和\(\forall w = 1, 2, \cdots,W_l\)。最后，我们沿方位角方向填充\(\mathcal{S}_l\)：

\[\begin{equation}\label{eq16} \begin{aligned} S_l^{pad}(h, p) &= \mathcal{S}_l^{pad}(h, W_l + p), \\ \text{and } S_l^{pad}(h, W_l + P + p) &=\mathcal{S}_l^{pad}(h, P + p), \end{aligned},\end{equation}\]

对于\(\forall p = 1, 2, \cdots,P\)和\(\forall w = 1, 2, \cdots,W_l\)。

得到\(S_l^{pad}\)后，我们就可以使用2D卷积来实现视点一致的对称卷积运算：

\[\begin{equation}\label{eq17} \mathcal{S}_{l + 1} = \text{Max}(\text{Conv}(\mathcal{S}_l^{pad};\kappa_l), \text{Conv}(\mathcal{S}_l^{pad}, \text{Flip}(\kappa_l))),\end{equation}\]

其中，\(\text{Conv}\)表示2D卷积、\(\text{Flip}\)表示卷积核的水平翻转、\(\text{Max}\)表示元素级最大池化。根据“PointNet:Deep Learning on Point Sets for 3D Classification andSegmentation”中的方法，\(\text{Max}\)作为对称函数来聚合特征，并保持视点一致的性质，补充材料中给出了此特性的证明。

6. Category-level 6DObject Pose Estimation

VI-Net估计\(\mathbf{R}, \mathbf{t},\mathbf{s}\)，且在推理时CAD模型不可用。给定一张RGBD图，首先使用MaskRCNN分割物体，对于每个裁剪出的具有点集\(\mathcal{P} =\{\mathbf{p}\}\)的物体，首先使用PointNet++估计\(\mathbf{t}\)和\(\mathbf{s}\)，然后在旋转估计时，将估计出的\(\mathbf{t}\)和\(\mathbf{s}\)作为初始化输入到VI-Net中进行归一化：\(\mathcal{P}^\prime = \{\frac{\mathbf{p} -\mathbf{t}}{\Vert\mathbf{s}\Vert}\}\)，最后使用VI-Net估计\(\mathbf{R}\)。

6.1. Experimental Setups

6.2. Comparisons withExisting Methods

6.3. Ablation Studies andAnalyses

7. Conclusion

以上信息截止至2025年7月9日17:49。

• 1 Core AMD EPYC 7002 Series
• 1 GB DDR4 RAM
• 20G NVMe SSD
• 1 IPV4
• 2T/Month/1Gbps
• International network, not optimized for China

购买链接：ZgoCloud -Los Angeles Global VPS - Specials - Starter

2025-03-30测试

ITDOG

https://www.itdog.cn/ping/：

结果图：ITDOG：23.159.*.*

IPQuality

xykt/IPQuality：

1

bash <(curl -Ls IP.Check.Place)

融合怪

spiritLHLS/ecs：

1

curl -L https://gitlab.com/spiritysdx/za/-/raw/main/ecs.sh -o ecs.sh && chmod +x ecs.sh && bash ecs.sh -m 1

https://paste.spiritlhl.net/#/show/MsgRY.txt

• 1 Core(s)
• 512 MB RAM
• 5 GB SSD Storage
• 1000 GB Bandwidth (in+out)
• 1 Gbps Global Port Shared
• 1 x IPv4 + 1 x /64 IPv6
• Virtualizor KVM
• Linux Only

购买链接：已停售。

2025-03-29测试

ITDOG

https://www.itdog.cn/ping/：

结果图：ITDOG：95.135.*.*

https://www.itdog.cn/ping_ipv6/：

结果图：ITDOG：2a14:67c1:b2aa:*:*:*:*:*

IPQuality

xykt/IPQuality：

1

bash <(curl -Ls IP.Check.Place)

IP质量体检报告：2a14:67c1:b2aa:*:*:*:*:*

融合怪

spiritLHLS/ecs：

1

curl -L https://gitlab.com/spiritysdx/za/-/raw/main/ecs.sh -o ecs.sh && chmod +x ecs.sh && bash ecs.sh -m 1

https://paste.spiritlhl.net/#/show/VGuBy.txt

• 位置：堪萨斯
• 架构：KVM
• CPU：1核心
• RAM：300M
• 硬盘：20G
• 流量：G口无限制
• IP：IPv6 1个
• 快照：1
• 母鸡：G口

2025-03-28测试

ITDOG

https://www.itdog.cn/ping_ipv6/：

结果图：ITDOG：2604:4300:a:*:*:*:*:*

IPQuality

xykt/IPQuality：

1

bash <(curl -Ls IP.Check.Place)

IP质量体检报告：2604:4300:a:*:*:*:*:*

融合怪

spiritLHLS/ecs：

1

curl -L https://gitlab.com/spiritysdx/za/-/raw/main/ecs.sh -o ecs.sh && chmod +x ecs.sh && bash ecs.sh -m 1

https://paste.spiritlhl.net/#/show/rebag.txt

在./provider/create_dataloaders.py中创建Dataloader，分别可以使用camera_real，camera和housecat6d三种创建方式，如果使用camera_real方式创建的话，camera和real的比例为3:1。

深度图加载

由于该方法使用到了CAMERA25和REAL25两个数据集，而CAMERA25数据集是一个合成数据集，其深度图为合成深度图，所以需要进行处理，下面是合成深度图的读取方法（注意这里读取的是./data/camera_full_depths/中的图，和./data/camera/中的不一样）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def load_composed_depth(img_path):
    """ Load depth image from img_path. """
    img_path_ = img_path.replace('/data/camera/', '/data/camera_full_depths/')
    depth_path = img_path_ + '_composed.png'
    if os.path.exists(depth_path):
        depth = cv2.imread(depth_path, -1)
        if len(depth.shape) == 3:
            # This is encoded depth image, let's convert
            # NOTE: RGB is actually BGR in opencv
            depth16 = depth[:, :, 1]*256 + depth[:, :, 2]
            depth16 = np.where(depth16==32001, 0, depth16)
            depth16 = depth16.astype(np.uint16)
        elif len(depth.shape) == 2 and depth.dtype == 'uint16':
            depth16 = depth
        else:
            assert False, '[ Error ]: Unsupported depth type.'
        return depth16
    else:
        print("warning: No data")
        return None

使用OpenCV读取./data/camera/train/00000/0000_depth.png，分别可视化其三个通道：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import cv2
import matplotlib.pyplot as plt

img_path = './data/camera/train/00000/0000'

depth_path = img_path + '_depth.png'
depth = cv2.imread(depth_path, -1)
plt.figure(figsize=(10, 5))
plt.subplot(131)
plt.title('depth[:, :, 0]')
plt.imshow(depth[:, :, 0])
plt.colorbar(shrink=0.5)
plt.subplot(132)
plt.title('depth[:, :, 1]')
plt.imshow(depth[:, :, 1])
plt.colorbar(shrink=0.5)
plt.subplot(133)
plt.title('depth[:, :, 2]')
plt.imshow(depth[:, :, 2])
plt.colorbar(shrink=0.5)
plt.show()

合成第1通道和第2通道：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import cv2
import numpy as np
import matplotlib.pyplot as plt

img_path = './data/camera/train/00000/0000'

depth_path = img_path + '_depth.png'
depth = cv2.imread(depth_path, -1)

depth_camera = depth[:, :, 1]*256 + depth[:, :, 2]
depth_camera = np.where(depth_camera==32001, 0, depth_camera)
depth_camera = depth_camera.astype(np.uint16)

plt.imshow(depth_camera)
plt.colorbar()
plt.show()

读取./data/camera_full_depths/train/00000/0000_composed.png，直接可视化：

1
2
3
4
5
6
7
8
9
10
11

import cv2
import matplotlib.pyplot as plt

img_path = './data/camera_full_depths/train/00000/0000'

depth_path = img_path + '_composed.png'
depth = cv2.imread(depth_path, -1)

plt.imshow(depth)
plt.colorbar()
plt.show()

下面是真实深度图的读取方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def load_depth(img_path):
    """ Load depth image from img_path. """
    depth_path = img_path + '_depth.png'
    depth = cv2.imread(depth_path, -1)
    if len(depth.shape) == 3:
        # This is encoded depth image, let's convert
        # NOTE: RGB is actually BGR in opencv
        depth16 = depth[:, :, 1]*256 + depth[:, :, 2]
        depth16 = np.where(depth16==32001, 0, depth16)
        depth16 = depth16.astype(np.uint16)
    elif len(depth.shape) == 2 and depth.dtype == 'uint16':
        depth16 = depth
    else:
        assert False, '[ Error ]: Unsupported depth type.'
    return depth16

直接读取./data/real/train/scene_1/0000_depth.png并可视化：

1
2
3
4
5
6
7
8
9
10
11

import cv2
import matplotlib.pyplot as plt

img_path = './data/real/train/scene_1/0000'

depth_path = img_path + '_depth.png'
depth_real = cv2.imread(depth_path, -1)

plt.imshow(depth_real)
plt.colorbar()
plt.show()

简单来说就是合成数据集读取的是./data/camera_full_depths/中的深度图，而真实数据集读取的是./data/real/中的深度图。

深度图补全

然后对深度图进行补全，分别对合成深度图和真实深度图进行补全：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import matplotlib.pyplot as plt
from utils.data_utils import fill_missing, load_depth, load_composed_depth

camera_img_path = './data/camera/train/00000/0000'
real_img_path = './data/real/train/scene_1/0000'

camera_depth = load_composed_depth(camera_img_path)
real_depth = load_depth(real_img_path)

fill_missing_camera = fill_missing(camera_depth, 1000.0, 1)
fill_missing_real = fill_missing(real_depth, 1000.0, 1)

plt.figure(figsize=(10, 5))
plt.subplot(121)
plt.imshow(fill_missing_camera)
plt.colorbar(shrink=0.5)
plt.subplot(122)
plt.imshow(fill_missing_real)
plt.colorbar(shrink=0.5)
plt.show()

mask加载

以下读取./data/camera/train/00000/0000_label.pkl中的内容：

1
2

with open(img_path + '_label.pkl', 'rb') as f:
    gts = cPickle.load(f)

gts的内容为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

{'class_ids': [1, 2, 6, 1],
 'bboxes': array([[ 50, 379, 222, 438],
        [224, 107, 325, 222],
        [ 21, 303,  83, 344],
        [  0,  78, 158, 187]], dtype=int32),
 'scales': array([0.3005802 , 0.21199934, 0.17190282, 0.42889243], dtype=float32),
 'sizes': array([[0.238512, 0.941394, 0.238512],
        [0.691974, 0.20577 , 0.691974],
        [0.685634, 0.549036, 0.477982],
        [0.210626, 0.926818, 0.31088 ]], dtype=float32),
 'rotations': array([[[ 0.98163134,  0.01207083, -0.19040541],
         [ 0.14415757, -0.7006575 ,  0.69878304],
         [-0.12497408, -0.7133957 , -0.6895274 ]],
 
        [[ 0.1414129 ,  0.01162317,  0.98988247],
         [-0.705418  , -0.7003605 ,  0.10899841],
         [ 0.69454145, -0.7136947 , -0.09084082]],
 
        [[ 0.02342262,  0.01182115,  0.9996558 ],
         [-0.71319616, -0.7005187 ,  0.02499446],
         [ 0.700573  , -0.7135361 , -0.00797719]],
 
        [[-0.98874557,  0.01170614,  0.14914814],
         [-0.11453401, -0.70061237, -0.7042899 ],
         [ 0.09625051, -0.7134461 ,  0.69406813]]], dtype=float32),
 'translations': array([[ 0.1340191 , -0.14495842,  0.8599784 ],
        [-0.20857327,  0.04460018,  0.7819705 ],
        [ 0.0061691 , -0.40006354,  1.2049764 ],
        [-0.31816682, -0.3390898 ,  0.9828115 ]], dtype=float32),
 'instance_ids': [2, 3, 4, 9],
 'model_list': ['ab6792cddc7c4c83afbf338b16b43f53',
  '7d7bdea515818eb844638317e9e4ff18',
  '73b8b6456221f4ea20d3c05c08e26f',
  'a1275bd03ab15100f6dbe3dc17d6cdf7']}

读取mask：

1

mask = cv2.imread(img_path + '_mask.png')[:, :, 2]

这里只取了第2通道，因为第2通道携带了类别信息：

1
2
3
4
5
6
7
8
9
10
11
12
13

mask = cv2.imread('./data/camera/train/00000/0000_mask.png')

unique_ids_0 = np.unique(mask[:, :, 0])
print("第0通道实例ID列表：", unique_ids_0)
# 第0通道实例ID列表： [  0 255]

unique_ids_1 = np.unique(mask[:, :, 1])
print("第1通道实例ID列表：", unique_ids_1)
# 第1通道实例ID列表： [  0 255]

unique_ids_2 = np.unique(mask[:, :, 2])
print("第2通道实例ID列表：", unique_ids_2)
# 第2通道实例ID列表： [  1   2   3   4   9 255]

与上方的instance_ids对应。

去除非目标物体的mask

首先随机选取一个物体（注意，训练时会从图像中所有物体中随机返回一个，而测试时则会全部返回）：

1

idx = np.random.randint(0, num_instance)

使用get_bbox：

1

rmin, rmax, cmin, cmax = get_bbox(gts['bboxes'][idx])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

def get_bbox(bbox):
    """ Compute square image crop window. """
    y1, x1, y2, x2 = bbox
    img_width = 480
    img_length = 640
    window_size = (max(y2 - y1, x2 - x1) // 40 + 1) * 40
    window_size = min(window_size, 440)
    center = [(y1 + y2) // 2, (x1 + x2) // 2]
    rmin = center[0] - int(window_size / 2)
    rmax = center[0] + int(window_size / 2)
    cmin = center[1] - int(window_size / 2)
    cmax = center[1] + int(window_size / 2)
    if rmin < 0:
        delt = -rmin
        rmin = 0
        rmax += delt
    if cmin < 0:
        delt = -cmin
        cmin = 0
        cmax += delt
    if rmax > img_width:
        delt = rmax - img_width
        rmax = img_width
        rmin -= delt
    if cmax > img_length:
        delt = cmax - img_length
        cmax = img_length
        cmin -= delt
    return rmin, rmax, cmin, cmax

以原boundingbox的中心为中心，生成长宽为40的倍数的boundingbox，并考虑了结果boundingbox超出图像范围的情况。

使用与操作去除其余物体的mask：

1
2

mask = np.equal(mask, gts['instance_ids'][idx])
mask = np.logical_and(mask , depth > 0)

从物体上采样

在后续得到物体点云后，需要从点云中采样固定数量的点以调整为网络需要的输入维度，在这一步实现。

1

choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0]

从mask中截取目标物体的一部分，然后展平，得到其非零值的下标。

采样到固定数量（配置文件中为1024）：

1
2
3
4
5
6

if len(choose) <= self.sample_num: # 1024
    choose_idx = np.random.choice(len(choose), self.sample_num)
else:
    choose_idx = np.random.choice(len(choose), self.sample_num, replace=False)

choose = choose[choose_idx]

将深度图转换为点云

获取内参：

1

cam_fx, cam_fy, cam_cx, cam_cy = self.intrinsics

（深度）归一化：

1

pts2 = depth.copy() / self.norm_scale

将像素坐标系中的xy坐标转换为相机坐标系中的xy坐标：

1
2
3
4

self.xmap = np.array([[i for i in range(640)] for j in range(480)])
self.ymap = np.array([[j for i in range(640)] for j in range(480)])
pts0 = (self.xmap - cam_cx) * pts2 / cam_fx
pts1 = (self.ymap - cam_cy) * pts2 / cam_fy

具体原理见：针孔相机成像模型

合并并裁剪：

1
2

pts = np.transpose(np.stack([pts0, pts1, pts2]), (1, 2, 0)).astype(np.float32)
pts = pts[rmin:rmax, cmin:cmax, :].reshape((-1, 3))[choose, :]

RGB

这里会将目标图像使用rmin, rmax, cmin, cmax进行裁剪，然后resize（代码中为\(224 \times224\)），那么相应的采样下标也需要修改。

除此之外，使用OpenCV读入RGB时，其维度顺序为HWC，在经过transforms.ToTensor()后，维度顺序会变为CHW。

修改采样下标

1
2
3
4
5
6
7
8

crop_w = rmax - rmin # 原本crop mask的宽度
ratio = self.img_size / crop_w # 缩放比例
col_idx = choose % crop_w # 原本列索引的相对位置
row_idx = choose // crop_w # 原本行索引的相对位置
choose = (np.floor(row_idx * ratio) * self.img_size + np.floor(col_idx * ratio)).astype(np.int64)
# np.floor(row_idx * ratio) 新行所在的位置
# np.floor(col_idx * ratio) 新列所在的位置
# np.floor(row_idx * ratio) * self.img_size + np.floor(col_idx * ratio) 新位置的索引

读取物体模型点云

首先是全部物体的模型点云，这里读取的是./data/obj_models/camera_train.pkl中的数据：

1
2
3

self.models = {}
with open(os.path.join(self.data_dir, model_path), 'rb') as f:
    self.models.update(cPickle.load(f))

该文件以字典的形式存储了物体的点云信息，可以通过键取出对应的点云：

1

model = self.models[gts['model_list'][idx]].astype(np.float32)

取出物体的平移、旋转和大小：

1
2
3
4
5

translation = gts['translations'][idx].astype(np.float32) # 3 物体坐标系到相机坐标系的平移
rotation = gts['rotations'][idx].astype(np.float32) # 3, 3 物体坐标系到相机坐标系的旋转
size = gts['scales'][idx] * gts['sizes'][idx].astype(np.float32) # 3
# gts['scales'][idx] 1 物体缩放比例
# gts['sizes'][idx] 3 物体长宽高

处理对称物体

1
2
3
4
5
6
7
8
9

if cat_id in self.sym_ids:
    theta_x = rotation[0, 0] + rotation[2, 2]
    theta_y = rotation[0, 2] - rotation[2, 0]
    r_norm = math.sqrt(theta_x**2 + theta_y**2)
    s_map = np.array([[theta_x/r_norm, 0.0, -theta_y/r_norm],
                        [0.0,            1.0,  0.0           ],
                        [theta_y/r_norm, 0.0,  theta_x/r_norm]])
    rotation = rotation @ s_map
# 绕Y轴旋转，这里假设Y轴朝上，Z轴朝前，X轴朝右，为右手系

Y轴朝上，所以第2列为\([0, 1,0]\)。

网络架构

RGB特征

使用DINOv2提取RGB特征：

1
2
3

self.rgb_extractor = torch.hub.load('facebookresearch/dinov2','dinov2_vits14')
for param in self.rgb_extractor.parameters():
    param.requires_grad = False

还使用了一个1d卷积：

1
2
3
4
5

self.feature_mlp = nn.Sequential(
    nn.Conv1d(384, 128, 1),
)

rgb_local = self.feature_mlp(dino_feature)

挑选RGB特征

在数据处理时，生成了一个choose变量，这里要用该变量将RGB特征从\(\mathbb{R}^{b \times 128 \times (196 \times196)}\)采样为\(\mathbb{R}^{b \times 128\times 1024}\)。

加噪

1
2
3

if self.training:
    delta_r, delta_t, delta_s = generate_augmentation(b)
    pts = (pts - delta_t) / delta_s.unsqueeze(2) @ delta_r

其中，生成噪声的函数为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

def generate_augmentation(batchsize):
    delta_t = torch.rand(batchsize, 1, 3).cuda() # b, 1, 3
    delta_t = delta_t.uniform_(-0.02, 0.02) # 将值重新采样到[-0.02, 0.02]范围

    angle_r = torch.randn(batchsize, 3) # b, 3
    angle_r.uniform_(-20, 20) # 将值重新采样到[-20, 20]范围
    angle_r = angle_r / 180 * torch.pi # b, 3 将角度转换为弧度

    delta_r_x = torch.eye(3).unsqueeze(0).repeat(batchsize, 1, 1) # b, 3, 3
    delta_r_y = torch.eye(3).unsqueeze(0).repeat(batchsize, 1, 1)
    delta_r_z = torch.eye(3).unsqueeze(0).repeat(batchsize, 1, 1)

    # 绕X轴旋转
    delta_r_x[:, 1, 1] = torch.cos(angle_r[:, 0])
    delta_r_x[:, 1, 2] = -torch.sin(angle_r[:, 0])
    delta_r_x[:, 2, 1] = torch.sin(angle_r[:, 0])
    delta_r_x[:, 2, 2] = torch.cos(angle_r[:, 0])

    # 绕Y轴旋转
    delta_r_y[:, 0, 0] = torch.cos(angle_r[:, 1])
    delta_r_y[:, 0, 2] = torch.sin(angle_r[:, 1])
    delta_r_y[:, 2, 0] = -torch.sin(angle_r[:, 1])
    delta_r_y[:, 2, 2] = torch.cos(angle_r[:, 1])

    # 绕Z轴旋转
    delta_r_z[:, 0, 0] = torch.cos(angle_r[:, 2])
    delta_r_z[:, 0, 1] = -torch.sin(angle_r[:, 2])
    delta_r_z[:, 1, 0] = torch.sin(angle_r[:, 2])
    delta_r_z[:, 1, 1] = torch.cos(angle_r[:, 2])

    # 组合旋转矩阵
    delta_r = torch.bmm(torch.bmm(delta_r_x, delta_r_y), delta_r_z).cuda()

    delta_s = torch.rand(batchsize, 1).cuda() # b, 1
    delta_s = delta_s.uniform_(0.8, 1.2) # 将值重新采样到[0.8, 1.2]范围

    return delta_r, delta_t, delta_s

模型会预测加噪后的位姿，然后在Loss阶段，会使用生成的噪声去除噪声，以实现数据增强。

点云特征

原文中说使用PointNet++来提取点云特征，但是暂时没有阅读过和PointNet++相关的论文，所以暂时不详细写。

IAKD

该模块以RGB特征和点云特征为输入，将点云特征和RGB特征进行拼接后作为\(KV\)、将可训练的一个查询向量作为\(Q\)，执行交叉注意力，返回处理后的查询向量和注意力图。

然后使用查询向量和输入特征做矩阵乘法，得到热图，最后返回查询向量和热图。

热图将拼接后的点云特征和RGB特征进一步压缩。

GAFA

首先使用一堆卷积和一堆全连接堆叠成GAFA块，然后使用两个GAFA块组成GAFA模块，最后返回关键点特征。

训练

这里训练和测试都使用的是Gorilla-Lab-SCUT/gorilla-core中的包。

测试

• 3 CPU Cores
• 4.5 GB RAM
• 16.6 TB Bandwidth

购买链接：黑五款，已停售。

2025-03-11测试

ITDOG

https://www.itdog.cn/ping/：

结果图：ITDOG：74.48.*.*

https://www.itdog.cn/ping_ipv6/：

结果图：ITDOG：2607:f130:0:*:*:*:*:*

IPQuality

xykt/IPQuality：

1

bash <(curl -Ls IP.Check.Place)

IP质量体检报告：2607:f130:0:*:*:*:*:*

融合怪

spiritLHLS/ecs：

1

curl -L https://gitlab.com/spiritysdx/za/-/raw/main/ecs.sh -o ecs.sh && chmod +x ecs.sh && bash ecs.sh -m 1

https://paste.spiritlhl.net/#/show/lbS2u.txt：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292

--------------------- A Bench Script By spiritlhl ----------------------
                   测评频道: https://t.me/vps_reviews
VPS融合怪版本：2025.02.12
Shell项目地址：https://github.com/spiritLHLS/ecs
Go项目地址：https://github.com/oneclickvirt/ecs
---------------------基础信息查询--感谢所有开源项目---------------------
 CPU 型号          : Intel(R) Xeon(R) CPU E5-2695 v2 @ 2.40GHz
 CPU 核心数        : 3
 CPU 频率          : 2399.998 MHz
 CPU 缓存          : L1: 192.00 KB / L2: 12.00 MB / L3: 48.00 MB
 AES-NI指令集      : ✔ Enabled
 VM-x/AMD-V支持    : ❌ Disabled
 内存              : 125.72 MiB / 4.33 GiB
 Swap              : 0 KiB / 2.25 GiB
 硬盘空间          : 1.86 GiB / 96.23 GiB
 启动盘路径        : /dev/vda1
 系统在线时间      : 0 days, 0 hour 18 min
 负载              : 0.26, 0.27, 0.18
 系统              : Ubuntu 20.04 LTS (x86_64)
 架构              : x86_64 (64 Bit)
 内核              : 5.4.0-28-generic
 TCP加速方式       : cubic
 虚拟化架构        : KVM
 NAT类型           : Full Cone
 IPV4 ASN          : AS35916 MULTACOM CORPORATION
 IPV4 位置         : Los Angeles / California / US
 IPV6 ASN          : AS35916 Multacom Corporation
 IPV6 位置         : Hedwig Village / Texas / United States
 IPV6 子网掩码     : 64
----------------------CPU测试--通过sysbench测试-------------------------
 -> CPU 测试中 (Fast Mode, 1-Pass @ 5sec)
 1 线程测试(单核)得分:          740 Scores
 3 线程测试(多核)得分:          2279 Scores
---------------------内存测试--感谢lemonbench开源-----------------------
 -> 内存测试 Test (Fast Mode, 1-Pass @ 5sec)
 单线程读测试:          15032.99 MB/s
 单线程写测试:          12425.39 MB/s
------------------磁盘dd读写测试--感谢lemonbench开源--------------------
 -> 磁盘IO测试中 (4K Block/1M Block, Direct Mode)
 测试操作               写速度                                  读速度
 100MB-4K Block         34.8 MB/s (8500 IOPS, 3.01s)            40.5 MB/s (9889 IOPS, 2.59s)
 1GB-1M Block           1.2 GB/s (1127 IOPS, 0.89s)             848 MB/s (808 IOPS, 1.24s)
---------------------磁盘fio读写测试--感谢yabs开源----------------------
Block Size | 4k            (IOPS) | 64k           (IOPS)
  ------   | ---            ----  | ----           ----
Read       | 76.91 MB/s   (19.2k) | 1.06 GB/s    (16.5k)
Write      | 77.12 MB/s   (19.2k) | 1.06 GB/s    (16.6k)
Total      | 154.03 MB/s  (38.5k) | 2.13 GB/s    (33.2k)
           |                      |
Block Size | 512k          (IOPS) | 1m            (IOPS)
  ------   | ---            ----  | ----           ----
Read       | 1.18 GB/s     (2.3k) | 1.19 GB/s     (1.1k)
Write      | 1.24 GB/s     (2.4k) | 1.26 GB/s     (1.2k)
Total      | 2.43 GB/s     (4.7k) | 2.46 GB/s     (2.4k)
------------流媒体解锁--基于oneclickvirt/CommonMediaTests开源-----------
以下测试的解锁地区是准确的，但是不是完整解锁的判断可能有误，这方面仅作参考使用
----------------Netflix-----------------
[IPV4]
您的出口IP完整解锁Netflix，支持非自制剧的观看
NF所识别的IP地域信息：美国
[IPV6]
您的出口IP可以使用Netflix，但仅可看Netflix自制剧
NF所识别的IP地域信息：美国
----------------Youtube-----------------
[IPV4]
连接方式: Youtube Video Server
视频缓存节点地域: 美国  洛杉机(LAX17S56)
[IPV6]
连接方式: Youtube Video Server
视频缓存节点地域: 美国  洛杉机(LAX31S13)
---------------DisneyPlus---------------
[IPV4]
当前IPv4出口所在地区即将开通DisneyPlus
[IPV6]
当前IPv4出口所在地区即将开通DisneyPlus
解锁Netflix，Youtube，DisneyPlus上面和下面进行比较，不同之处自行判断
----------------流媒体解锁--感谢RegionRestrictionCheck开源--------------
 以下为IPV4网络测试，若无IPV4网络则无输出
============[ Multination ]============
 Dazn:                                  Yes (Region: US)
 Disney+:                               Yes (Region: US)
 Netflix:                               Yes (Region: US)
 YouTube Premium:                       Yes (Region: US)
 Amazon Prime Video:                    Yes (Region: US)
 TVBAnywhere+:                          Yes
 Spotify Registration:                  No
 OneTrust Region:                       US [California]
 iQyi Oversea Region:                   US
 Bing Region:                           US (Risky)
 Apple Region:                          US
 YouTube CDN:                           Los Angeles, CA
 Netflix Preferred CDN:                 Los Angeles, CA
 ChatGPT:                               Yes
 Google Gemini:                         Yes (Region: USA)
 Claude:                                Yes
 Wikipedia Editability:                 No
 Google Play Store:                     United States
 Google Search CAPTCHA Free:            Yes
 Steam Currency:                        USD
 ---Forum---
 Reddit:                                Yes
=======================================
 以下为IPV6网络测试，若无IPV6网络则无输出
============[ Multination ]============
 Dazn:                                  IPv6 Is Not Currently Supported
 Disney+:                               IPv6 Is Not Currently Supported
 Netflix:                               Originals Only
 YouTube Premium:                       Yes (Region: US)
 Amazon Prime Video:                    IPv6 Is Not Currently Supported
 TVBAnywhere+:                          IPv6 Is Not Currently Supported
 Spotify Registration:                  No
 OneTrust Region:                       US [Texas]
 iQyi Oversea Region:                   IPv6 Is Not Currently Supported
 Bing Region:                           US (Risky)
 Apple Region:                          US
 YouTube CDN:                           Los Angeles, CA
 Netflix Preferred CDN:                 Los Angeles, CA
 ChatGPT:                               Failed (Network Connection)
 Google Gemini:                         Yes (Region: USA)
 Claude:                                Yes
 Wikipedia Editability:                 No
 Google Play Store:                     United States
 Google Search CAPTCHA Free:            Yes
 Steam Currency:                        IPv6 Is Not Currently Supported
 ---Forum---
 Reddit:                                IPv6 Is Not Currently Supported
=======================================
---------------TikTok解锁--感谢lmc999的源脚本及fscarmen PR--------------
 Tiktok Region:         【US】
-------------IP质量检测--基于oneclickvirt/securityCheck使用-------------
数据仅作参考，不代表100%准确，如果和实际情况不一致请手动查询多个数据库比对
以下为各数据库编号，输出结果后将自带数据库来源对应的编号
ipinfo数据库  [0] | scamalytics数据库 [1] | virustotal数据库   [2] | abuseipdb数据库   [3] | ip2location数据库    [4]
ip-api数据库  [5] | ipwhois数据库     [6] | ipregistry数据库   [7] | ipdata数据库      [8] | db-ip数据库          [9]
ipapiis数据库 [A] | ipapicom数据库    [B] | bigdatacloud数据库 [C] | cheervision数据库 [D] | ipqualityscore数 据库 [E]
IPV4:
安全得分:
声誉(越高越好): 0 [2]
信任得分(越高越好): 0 [8]
VPN得分(越低越好): 100 [8]
代理得分(越低越好): 100 [8]
社区投票-无害: 0 [2]
社区投票-恶意: 0 [2]
威胁得分(越低越好): 100 [8]
欺诈得分(越低越好): 39 [1] 65 [E]
滥用得分(越低越好): 0 [3]
ASN滥用得分(越低越好): 0.0001 (Very Low) [A]
公司滥用得分(越低越好): 0.0011 (Low) [A]
威胁级别: low [B]
黑名单记录统计:(有多少黑名单网站有记录):
无害记录数: 0 [2]  恶意记录数: 0 [2]  可疑记录数: 0 [2]  无记录数: 94 [2]
安全信息:
使用类型: isp [A] hosting [0 7] hosting - moderate probability [C] DataCenter/WebHosting/Transit [3] business [8]
公司类型: isp [A] hosting [0 7]
是否云提供商: Yes [7 D]
是否数据中心: No [8 A C] Yes [0 1 5 6]
是否移动设备: Yes [E] No [5 A C]
是否代理: No [0 1 4 5 6 7 8 A B C D] Yes [E]
是否VPN: Yes [A E] No [0 1 6 7 C D]
是否Tor: No [0 1 3 6 7 8 A B C D E]
是否Tor出口: No [1 7 D]
是否网络爬虫: No [A B E]
是否匿名: No [1 6 7 8 D]
是否攻击者: No [7 8 D]
是否滥用者: No [7 8 A C D E]
是否威胁: No [7 8 C D]
是否中继: No [0 7 8 C D]
是否Bogon: No [7 8 A C D]
是否机器人: No [E]
DNS-黑名单: 313(Total_Check) 0(Clean) 4(Blacklisted) 18(Other)
IPV6:
安全得分:
欺诈得分(越低越好): 21 [1]
滥用得分(越低越好): 0 [3]
ASN滥用得分(越低越好): 0.0001 (Very Low) [A]
公司滥用得分(越低越好): 0 (Very Low) [A]
威胁级别: low [B]
安全信息:
使用类型: DataCenter/WebHosting/Transit [3] isp [A]
公司类型: isp [A]
是否云提供商: Yes [D]
是否数据中心: Yes [1] No [A]
是否移动设备: No [A]
是否代理: No [1 A B D]
是否VPN: No [1 A D]
是否TorExit: No [1 D]
是否Tor出口: No [1 D]
是否网络爬虫: No [A B]
是否匿名: No [1 D]
是否攻击者: No [D]
是否滥用者: No [A D]
是否威胁: No [D]
是否中继: No [D]
是否Bogon: No [A D]
DNS-黑名单: 313(Total_Check) 0(Clean) 0(Blacklisted) 313(Other)
Google搜索可行性：NO
-------------邮件端口检测--基于oneclickvirt/portchecker开源-------------
Platform  SMTP  SMTPS POP3  POP3S IMAP  IMAPS
LocalPort ✔     ✔     ✔     ✔     ✔     ✔
QQ        ✔     ✔     ✔     ✘     ✔     ✘
163       ✔     ✔     ✔     ✘     ✔     ✘
Sohu      ✔     ✔     ✔     ✘     ✔     ✘
Yandex    ✔     ✔     ✔     ✘     ✔     ✘
Gmail     ✔     ✔     ✘     ✘     ✘     ✘
Outlook   ✔     ✘     ✔     ✘     ✔     ✘
Office365 ✔     ✘     ✔     ✘     ✔     ✘
Yahoo     ✔     ✔     ✘     ✘     ✘     ✘
MailCOM   ✔     ✔     ✔     ✘     ✔     ✘
MailRU    ✔     ✔     ✘     ✘     ✔     ✘
AOL       ✔     ✔     ✘     ✘     ✘     ✘
GMX       ✔     ✘     ✔     ✘     ✔     ✘
Sina      ✔     ✔     ✔     ✘     ✔     ✘
Apple     ✘     ✔     ✘     ✘     ✘     ✘
FastMail  ✘     ✔     ✘     ✘     ✘     ✘
ProtonMail✘     ✘     ✘     ✘     ✘     ✘
MXRoute   ✔     ✘     ✔     ✘     ✔     ✘
Namecrane ✔     ✔     ✔     ✘     ✔     ✘
XYAMail   ✘     ✘     ✘     ✘     ✘     ✘
ZohoMail  ✘     ✔     ✘     ✘     ✘     ✘
Inbox_eu  ✔     ✔     ✔     ✘     ✘     ✘
Free_fr   ✘     ✔     ✔     ✘     ✔     ✘
----------------三网回程--基于oneclickvirt/backtrace开源----------------
北京电信 219.141.140.10  检测不到回程路由节点的IP地址
北京联通 202.106.195.68  联通4837   [普通线路]
北京移动 221.179.155.161 移动CMI    [普通线路]
上海电信 202.96.209.133  电信163    [普通线路]
上海联通 210.22.97.1     联通4837   [普通线路]
上海移动 211.136.112.200 移动CMI    [普通线路]
广州电信 58.60.188.222   电信163    [普通线路]
广州联通 210.21.196.6    联通4837   [普通线路]
广州移动 120.196.165.24  移动CMI    [普通线路]
成都电信 61.139.2.69     电信163    [普通线路]
成都联通 119.6.6.6       联通4837   [普通线路]
成都移动 211.137.96.205  移动CMI    [普通线路]
准确线路自行查看详细路由，本测试结果仅作参考
同一目标地址多个线路时，可能检测已越过汇聚层，除了第一个线路外，后续信息可能无效
---------------------回程路由--感谢fscarmen开源及PR---------------------
依次测试电信/联通/移动经过的地区及线路，核心程序来自nexttrace，请知悉!
广州电信 58.60.188.222
0.86 ms         AS35916 美国 加利福尼亚 洛杉矶 multacom.com
1.05 ms         AS35916 美国 加利福尼亚州 洛杉矶 multacom.com
7.05 ms         AS2914 [NTTA-128] 美国 加利福尼亚 洛杉矶 gin.ntt.net
0.68 ms         AS2914 [NTT-BACKBONE] 美国 加利福尼亚 洛杉矶 gin.ntt.net
9.11 ms         AS2914 [NTT-BACKBONE] 美国 加利福尼亚 圣何塞 gin.ntt.net
9.28 ms         AS2914 [NTT-BACKBONE] 美国 加利福尼亚 圣何塞 gin.ntt.net
13.49 ms        AS4134 [CHINANET-US] 美国 加利福尼亚 圣克拉拉 www.chinatelecom.com.cn 电信
161.59 ms       AS4134 [CHINANET-BB] 中国 广东 广州 www.chinatelecom.com.cn 电信
160.32 ms       AS4134 [CHINANET-BB] 中国 广东 广州 www.chinatelecom.com.cn 电信
165.19 ms       AS4134 中国 广东 深圳 福田区 www.chinatelecom.com.cn 电信
广州联通 210.21.196.6
1.16 ms         AS35916 美国 加利福尼亚 洛杉矶 multacom.com
2.36 ms         AS35916 美国 加利福尼亚州 洛杉矶 multacom.com
0.90 ms         AS64050 [BCPL-SG] 新加坡 bgp.net
14.88 ms        AS4837 [CU169-BACKBONE] 美国 加利福尼亚 圣何塞 chinaunicom.cn 联通
157.18 ms       AS4837 [CU169-BACKBONE] 中国 北京 chinaunicom.cn 联通
178.71 ms       AS4837 [CU169-BACKBONE] 中国 北京 chinaunicom.cn 联通
193.06 ms       AS17816 [UNICOM-GD] 中国 广东 深圳 chinaunicom.cn 联通
195.11 ms       AS17623 [APNIC-AP] 中国 广东 深圳 chinaunicom.cn 联通
214.31 ms       AS17623 中国 广东 深圳 宝安区 chinaunicom.cn 联通
广州移动 120.196.165.24
0.88 ms         AS35916 美国 加利福尼亚 洛杉矶 multacom.com
1.06 ms         AS35916 美国 加利福尼亚州 洛杉矶 multacom.com
5.97 ms         AS2914 [NTTA-128] 美国 加利福尼亚 洛杉矶 gin.ntt.net
0.72 ms         AS2914 [NTT-BACKBONE] 美国 加利福尼亚 洛杉矶 gin.ntt.net
1.10 ms         AS2914 [NTT-BACKBONE] 美国 加利福尼亚 洛杉矶 gin.ntt.net
210.30 ms       AS2914 [NTT-BACKBONE] 日本 大阪府 大阪 gin.ntt.net
264.74 ms       AS2914 [NTT-BACKBONE] 中国 香港 gin.ntt.net
162.02 ms       AS2914 [NTT-BACKBONE] 中国 香港 gin.ntt.net
154.15 ms       AS58453 [CMI-INT] 中国 香港 cmi.chinamobile.com 移动
148.17 ms       AS58453 [CMI-INT] 中国 广东 广州 cmi.chinamobile.com 移动
162.94 ms       AS9808 [CMNET] 中国 广东 广州 chinamobileltd.com 移动
163.22 ms       AS9808 [CMNET] 中国 广东 广州 I-C chinamobileltd.com 移动
166.40 ms       AS9808 [CMNET] 中国 广东 广州 chinamobileltd.com 移动
209.93 ms       AS9808 [CMNET] 中国 广东 广州 chinamobileltd.com 移动
157.25 ms       AS56040 [APNIC-AP] 中国 广东 深圳 gd.10086.cn 移动
--------------------自动更新测速节点列表--本脚本原创--------------------
位置             上传速度        下载速度        延迟     丢包率
Speedtest.net    847.28 Mbps     849.00 Mbps     0.52     0.0%
洛杉矶           804.29 Mbps     836.19 Mbps     1.00     0.0%
日本东京         841.07 Mbps     146.15 Mbps     102.80   0.0%
联通上海5G       475.84 Mbps     931.15 Mbps     179.97   0.0%
联通Beijing      700.53 Mbps     151.27 Mbps     158.41   NULL
电信Zhenjiang5G  36.45 Mbps      220.96 Mbps     148.83   NULL
电信浙江         4.87 Mbps       34.35 Mbps      150.15   NULL
移动Fujian       412.00 Mbps     49.55 Mbps      212.57   NULL
------------------------------------------------------------------------
 总共花费      : 7 分 27 秒
 时间          : Tue Mar 11 10:57:31 GMT 2025
------------------------------------------------------------------------
  短链:
    https://paste.spiritlhl.net/#/show/lbS2u.txt
    http://hpaste.spiritlhl.net/#/show/lbS2u.txt