CheckerPose: Progressive Dense Keypoint Localization for Object Pose
  Estimation with Graph Neural Network
Estimating the 6-DoF pose of a rigid object from a single RGB image is a
crucial yet challenging task. Recent studies have shown the great potential of
dense correspondence-based solutions, yet improvements are still needed to
reach practical deployment. In this paper, we propose a novel pose estimation
algorithm named CheckerPose, which improves on three main aspects. Firstly,
CheckerPose densely samples 3D keypoints from the surface of the 3D object and
finds their 2D correspondences progressively in the 2D image. Compared to
previous solutions that conduct dense sampling in the image space, our strategy
enables the correspondence searching in a 2D grid (i.e., pixel coordinate).
Secondly, for our 3D-to-2D correspondence, we design a compact binary code
representation for 2D image locations. This representation not only allows for
progressive correspondence refinement but also converts the correspondence
regression to a more efficient classification problem. Thirdly, we adopt a
graph neural network to explicitly model the interactions among the sampled 3D
keypoints, further boosting the reliability and accuracy of the
correspondences. Together, these novel components make CheckerPose a strong
pose estimation algorithm. When evaluated on the popular Linemod, Linemod-O,
and YCB-V object pose estimation benchmarks, CheckerPose clearly boosts the
accuracy of correspondence-based methods and achieves state-of-the-art
performances. Code is available at https://github.com/RuyiLian/CheckerPose.
Ruyi Lian, Haibin Ling
CheckerPose: Progressive Dense Keypoint Localization for Object Pose Estimation with Graph Neural Network

###### Abstract

Estimating the 6-DoF pose of a rigid object from a single RGB image is a crucial yet challenging task. Recent studies have shown the great potential of dense correspondence-based solutions, yet improvements are still needed to reach practical deployment. In this paper, we propose a novel pose estimation algorithm named _CheckerPose_, which improves on three main aspects. Firstly, CheckerPose densely samples 3D keypoints from the surface of the 3D object and finds their 2D correspondences progressively in the 2D image. Compared to previous solutions that conduct dense sampling in the image space, our strategy enables the correspondence searching in a 2D grid (i.e., pixel coordinate). Secondly, for our 3D-to-2D correspondence, we design a compact binary code representation for 2D image locations. This representation not only allows for progressive correspondence refinement but also converts the correspondence regression to a more efficient classification problem. Thirdly, we adopt a graph neural network to explicitly model the interactions among the sampled 3D keypoints, further boosting the reliability and accuracy of the correspondences. Together, these novel components make our CheckerPose a strong pose estimation algorithm. When evaluated on the popular Linemod, Linemod-O, and YCB-V object pose estimation benchmarks, CheckerPose clearly boosts the accuracy of correspondence-based methods and achieves state-of-the-art performances.

## 1 Introduction

Object pose estimation from RGB images aims to estimate the rotation and translation of a given rigid object relative to the camera. It is crucial in various applications including robot grasping and manipulation [80, 66, 67], autonomous driving [42, 74, 34], augmented reality [43, 63], _etc._ Most existing methods [54, 64, 44, 22, 49, 77, 46, 38, 58] first estimate an intermediate geometric representation, _i.e_., the correspondences between 3D object keypoints and 2D image locations, and then recover the object pose using the Perspective-n-Point (PnP) algorithm. Theoretically, for a rigid object, four pairs of 3D-2D correspondences can determine a unique pose [53, 12, 50]. In practice, however, sparse correspondences easily degrade due to occlusion, background clutter, lighting variation, _etc._

Increasing the number of 3D-2D correspondences is a feasible solution to enhance robustness, especially when combined with outlier removal mechanisms such as RANSAC. Recent methods [77, 46, 38, 18, 21, 71, 10] densely sample 2D image pixels and predict their 3D object coordinates. While these dense predictions improve the robustness of pose estimation, they have several drawbacks. Firstly, the predictions consider only visible pixels and ignore global relations b

Figure 1: **Illustration of CheckerPose. We evenly sample dense keypoints from the surface of the object, and predict the 2D locations in the input image. We design a binary code representation to progressively localize each keypoint in the iteratively refined 2D grids. To improve the localization results, we also use graph neural networks to explicitly model the interactions between 3D keypoints. Note: we plot 8 keypoints for better visualization, while we use 512 keypoints in practice.**
keypoints, making them unstable when the object is under severe occlusions. Secondly, estimating the corresponding 3D coordinates is nontrivial. Finally, the rich shape prior information is not effectively encoded.

To overcome the above issues, we propose a novel 6D pose estimation algorithm, named _CheckerPose_, which improves dense correspondence with three cooperative components: dense 3D sampling, progressive 2D localization through binary coding, and shape prior encoding with graph neural network, as illustrated in Figure 1.

For dense correspondence, CheckerPose samples 3D keypoints on the object surface and then finds their 2D pixel correspondences in the 3D-to-2D matching way. Compared to previous solutions that conduct dense sampling in the 2D image space, our strategy enables more efficient correspondence searching in a 2D grid (, pixel coordinate) using 2D binary coding, as well as explicit shape prior modeling with graph representation.

Then, to facilitate the localization of dense keypoints, we propose a 2D hierarchical binary coding to represent a 2D image position. Specifically, we superpose a grid on the input image and predict which cells contain the desired keypoints. The precision of the 2D keypoint location is controlled by the resolution of the grid. This novel representation allows us to refine the correspondence progressively. We first localize the keypoints in the \(2\times 2\) grid, and then iteratively subdivide each cell and localize the keypoints in the refined grid. Inspired by ZebraPose [61], we use binary codes on the \(x\) and \(y\) directions to represent each cell, which makes the grids have a checkerboard pattern.

Furthermore, to capture the shape prior of the 3D object, we adopt a graph neural network to explicitly model the interactions among the sampled 3D keypoints and to guide the progressive correspondence estimation. In particular, we construct the \(k\)-nearest neighbor (\(k\)-NN) graph of the dense keypoints and utilize graph network layers to fuse information from a keypoint and its neighbors. By stacking multiple such layers, we can capture non-local interactions between invisible and visible keypoints, and thus significantly improve the prediction robustness of invisible keypoints.

To summarize, our main contributions are as follows:

* We propose to localize dense 3D keypoints in the input image, to establish dense correspondences for instance-level object pose estimation.
* We design a hierarchical binary coding strategy for 2D projections, which enables progressive localization of dense keypoints.
* We utilize graph neural networks to explicitly model the interactions between 3D keypoints and improve the predictions of invisible keypoints.

Together, these novel contributions make our CheckerPose a strong pose estimation algorithm. We conduct extensive experiments on the popular benchmarks including Linemod [17], Linemod-Occlusion [2], and YCB-V [75], and CheckerPose consistently achieves state-of-the-art performances. We will release the source code of our CheckerPose upon the publication of the work.

## 2 Related Work

In this section we review previous studies that are closely related to our work, mainly including different types of pose estimators and graph neural networks.

Direct Methods.Given an input RGB image, direct methods estimate the 6D pose of the object in the image without intermediate geometric representations,, 3D-2D correspondences. Traditional direct methods mainly adopt template matching techniques with hand-crafted features [25, 13, 16], and thus can not handle textureless objects well. Recent deep learning based methods utilize features learned by CNNs to directly regress 6D pose [75] or formulate the rotation estimation as a classification task by discretizing the rotation space \(SO(3)\)[68, 60, 28, 62].

Correspondence Guided Methods.Instead of direct estimation, correspondence guided methods [48, 54, 64, 44, 22, 49, 21, 23, 77, 46, 38, 71, 10, 61] follow a two-stage framework: they first predict a set of correspondences between 3D object frame coordinates and 2D image plane coordinates, and then recover the pose from the 3D-2D correspondences with a PnP algorithm [32, 30, 11, 69, 6]. RANSAC can be used to remove the outliers in the correspondences. Keypoint-localization based methods [48, 54, 64, 44, 22, 49, 21, 23] estimate the 2D coordinates for a sparse set of predefined 3D keypoints, while dense methods [77, 46, 38, 71, 10, 61] predict the 3D object frame coordinate of each 2D image pixel. Compared with sparse correspondences, dense correspondences contain richer context information of the scene and is more robust to occlusion.

Graph Neural Networks for 3D Vision.In 3D vision tasks, point clouds and meshes are important input data formats since they can efficiently represent complex shapes. Compared with convolutional neural networks (CNNs), graph neural networks (GNNs) [59] can handle inputs with irregular structures and effectively model the long-range dependencies, and thus are widely used for processing point clouds and meshes. While meshes can be naturally treated as graphs, a common practice of constructing graphs from point clouds is to treat each 3D point as graph nodes and connect each node to its \(k\) nearest neighbors [73, 57, 8]. GNN-based methods have been proposed for representation learning [57, 73, 40, 70], detection [56, 8], segmentation [51, 33], data generation [52, 39], camera pose inference [35, 36],. For object pose estimation, GNNs are mainly used for RGB-D inputs [9, 79] to enhance the feature extraction from different modalities. Another recent
application is to learn geometric structures of the sparse keypoints for domain adaptation [78].

**Our work** follows the two-stage framework and combines the strengths of both keypoint-based methods and dense methods, by localizing a dense set of predefined 3D keypoints to establish dense correspondences. Moreover, it utilizes GNNs to efficiently model the interactions among dense 3D keypoints and thus improve the localization in the input RGB image for monocular object pose estimation.

## 3 Method

### Problem Formulation and Method Overview

Given an RGB image \(I\) and a rigid object \(O\), our goal is to estimate rotation \(\mathbf{R}\in SO(3)\) and translation \(\mathbf{t}\in\mathbb{R}^{3}\) of \(O\) relative to the calibrated camera. We assume the 3D geometry information, _e.g_., the 3D CAD model, is available, thus we can obtain \(N(N\gg 8)\) keypoints \(\mathcal{P}\) from the object surface using farthest point sampling (FPS) algorithm.

We adopt a two-stage pipeline for object pose estimation: we first predict 2D projection \(\mathbf{\rho}\in\mathbb{R}^{2}\) for each keypoint \(P\in\mathbb{R}^{3}\), and then regress the rotation and translation from the 3D-2D correspondences via a PnP solver. For the input RGB image, we use an off-the-shelf object detector [55, 65] to detect the object bounding box and extract the zoomed-in Region of Interest (RoI) \(I_{O}\), following the common practice in instance-level object pose estimation [38, 71, 10, 61]. Figure 2 illustrates our proposed pipeline. We first process the input RoI \(I_{O}\) by a backbone network to obtain backbone feature \(F_{I}^{(0)}\) and keypoint embedding \(F_{G}^{(0)}\) in the \(k\)-NN graph \(\mathcal{G}\). Then we use graph network layers (_i.e_., EdgeConv [73]) to progressively localize the keypoints, which are represented as binary codes \(\mathbf{b_{v}},\mathbf{b_{x}}\), and \(\mathbf{b_{y}}\). We also use a standard CNN decoder to transform \(F_{I}^{(0)}\) to a series of image feature maps, and fuse the features in the graph neural network based on the current predicted locations. The CNN decoder also outputs object segmentation masks \(M\) as an auxiliary learning task. Finally, we convert the binary codes to 2D coordinates and use a PnP solver to recover the pose from the established correspondences. We describe our method, named _CheckerPose_ due to the checkerboard-like binary pattern, in details as follows.

### Hierarchical Representation of 2D Keypoint Locations

Establishing 3D-2D correspondences provides an intermediate representation for object pose estimation. In this

Figure 2: **Framework of our progressive dense keypoint localization with graph neural network, _i.e_., CheckerPose. Given an RGB image and object detection results, we progressively generate the binary codes representing the 2D locations of \(N\) 3D keypoints. (a) Initial graph embedding generation: we use a CNN backbone network to extract feature \(F_{I}^{(0)}\) from the zoomed-in RoI \(I_{O}\), and then transform \(F_{I}^{(0)}\) to the initial keypoint embeddings \(F_{G}^{(0)}\) in the \(k\)-NN graph \(\mathcal{G}\). (b) Progressive prediction: we use a graph neural network to generate the binary code representation in a coarse-to-fine manner. We adopt an additional CNN decoder network to generate image features from \(F_{I}^{(0)}\), and fuse the features in the graph neural network based on current predictions. Object segmentation masks \(M\) are predicted as an auxiliary learning task.**
work, we focus on localizing a dense set of predefined 3D keypoints \(\mathcal{P}\) in the 2D image plane. For \(N(N\gg 8)\) 3D keypoints \(\mathcal{P}\), we first predict whether their 2D projections appear in the RoI \(I_{O}\), and then localize the keypoints inside \(I_{O}\), denoted as \(\mathcal{P}_{I}\). In contrast to directly regressing the precise coordinates, we superpose a \(2^{d}\times 2^{d}\) grid \(S\) on the RoI \(I_{O}\) and predict which cell \(s\in S\) contains the 2D projection \(\mathbf{\rho}\) (Figure 3 (a)). Then we can use the coordinate of the cell center to approximate \(\mathbf{\rho}\), and only need to predict the discrete index \((i_{x},i_{y})(0\leq i_{x},i_{y}\leq 2^{d}-1)\) of the cell \(s\), which is much easier than precise regression. The localization precision is controlled by the resolution of the grid \(S\), and approaches the actual 2D projection as \(d\rightarrow\infty\).

Based on the approximate representation, we can further localize the keypoint \(P\in\mathcal{P}_{I}\) in a coarse-to-fine manner. As shown in Figure 3 (b), at the beginning, we superpose a \(2\times 2\) grid \(S^{(1)}\) on the RoI \(I_{O}\) and predict the index of the cell \(s_{P}^{(1)}\). Then at iteration \(j\)\((2\leq j\leq d)\), we increase the grid resolution from \(2^{j-1}\times 2^{j-1}\) to \(2^{j}\times 2^{j}\) by evenly splitting each cell \(s^{(j-1)}\in S^{(j-1)}\) into halves on both \(x\) and \(y\) directions. With the prediction of \(s_{P}^{(j-1)}\) in iteration \(j-1\), we only need to search the corresponding \(2\times 2\) sub-cells to find \(s_{P}^{(j)}\) in the refined grid \(S^{(j)}\).

Inspired by ZebraPose [61], we use binary codes to concisely represent the hierarchical localization. For the cell \(s_{P}\) in the final \(2^{d}\times 2^{d}\) grid \(S\), we use a \(d\)-bit binary code \(\mathbf{b_{x}}\) to represent the index \(i_{x}\) as

\[i_{x}=\sum_{k=1}^{d}b_{x}(k)\times 2^{d-k}, \tag{1}\]

where \(b_{x}(k)\) is the \(k\)-th bit of \(\mathbf{b_{x}}\). We use another \(d\)-bit binary code \(\mathbf{b_{y}}\) to represent the index \(i_{y}\) in the same way. The first \(j(1\leq j\leq d)\) bits of \(\mathbf{b_{x}}\) and \(\mathbf{b_{y}}\) also represent the cell \(s_{P}^{(j)}\in S^{(j)}\). We use an additional 1-bit binary code \(\mathbf{b_{v}}\) to indicate the existence of the projection \(\mathbf{\rho}\) in the RoI \(I_{O}\), where \(\mathbf{b_{v}}=1\) means \(\mathbf{\rho}\in I_{O}\) while \(\mathbf{b_{v}}=0\) means \(\mathbf{\rho}\notin I_{O}\).

Compared with dense representations like heatmaps [48, 44] and vector-fields [49, 22], our novel representation needs only \(2d+1\) binary bits for each keypoint, thus greatly reduces the memory usage for dense keypoint localization. In addition, during inference, we can efficiently convert the binary codes to the 2D coordinates. Furthermore, our representation can be naturally predicted in a progressive way, which allows to gradually improve the localization via iterative refinements.

### Dense Keypoint Localization via Graph Neural Network

Modeling the interactions among the keypoints \(\mathcal{P}\) is crucial for predicting their 2D locations. For the keypoints that are invisible due to occlusions or self-occlusions, the features of the visible ones provide additional clues to infer the 2D locations. However, previous keypoint-based methods mainly use convolutional neural networks (CNNs), which can not handle inputs with irregular structure and thus fail to explicitly capture the interactions among \(\mathcal{P}\).

We instead utilize graph neural networks (GNNs) to process the features \(F=\{f_{1},\cdots,f_{N}\}\) of \(N\) keypoints \(\mathcal{P}\). To construct a graph \(\mathcal{G}\) from \(\mathcal{P}\), we treat each keypoint \(P_{i}\in\mathcal{P}(1\leq i\leq N)\) as a graph node, and connect \(P_{i}\) to its \(k\) nearest neighbors in 3D Euclidean space to generate edges \(\mathcal{E}\). We adopt the EdgeConv operation [73] as our graph network layer, which directly models local interactions between \(P_{i}\) and its neighbors. For edge \((i,j)\in\mathcal{E}\), we compute the feature \(e_{ij}\) as

\[e_{ijm}=\mathrm{ReLU}(\theta_{m}\cdot(f_{j}-f_{i})+\phi_{m}\cdot f_{i}), \tag{2}\]

where \(e_{ijm}\) is the \(m\)-th channel of \(e_{ij}\), and \(\theta_{m},\phi_{m}\) are the weights of the filters. The feature of \(P_{i}\) is updated by aggregating the edge features as

\[f_{im}^{{}^{\prime}}=\max_{j:(i,j)\in\mathcal{E}}e_{ijm}, \tag{3}\]

where \(f_{im}^{{}^{\prime}}\) is the \(m\)-th channel of updated feature \(f_{i}^{{}^{\prime}}\). By stacking multiple EdgeConv operations, our network can gradually learn the non-local interactions in a computational-efficient way for dense keypoints \(\mathcal{P}\).

As shown in Figure 2 (a), to obtain the initial keypoint embeddings \(F_{G}^{(0)}\) in \(\mathcal{G}\), we first use a backbone network to extract a \(C_{0}\times 2^{d_{0}}\times 2^{d_{0}}\) feature map \(F_{I}^{(0)}\) from RoI \(I_{O}\), where \(C_{0}\) is the number of the feature channels, and \(2^{d_{0}}\times 2^{d_{0}}\) is the spatial size. We then reshape \(F_{I}^{(0)}\) to

Figure 3: **Illustration of our keypoint location representation.** (a) We represent the 2D projection coordinate as the center of the cell containing the 2D projection. (b) We iteratively refine the grid and represent the cell as binary codes \(\mathbf{b_{x}},\mathbf{b_{y}}\).
\(C_{0}\times 2^{2d_{0}}\) by flattening the spatial dimensions, and use a 1D convolutional network layer to obtain a \(N\times 2^{2d_{0}}\) feature map, which is regarded as the initial \(2^{2d_{0}}\)-dimensional embeddings \(F_{G}^{(0)}\) for \(N\) keypoints.

After obtaining \(F_{G}^{(0)}\), we use graph neural network to predict the 1-bit indicator code \(\mathbf{b_{v}}\), and progressively generate the \(d\)-bit index codes \(\mathbf{b_{x}},\mathbf{b_{y}}\). Specifically, at stage 0, we apply \(L_{0}\) EdgeConv [73] operations to \(F_{G}^{(0)}\) to get the updated embeddings \(F_{G}^{(1)}\), and then use shared MLPs to generate \(\mathbf{b_{v}}\) and the first \(d_{0}\) bits of \(\mathbf{b_{x}},\mathbf{b_{y}}\), respectively. Then at stage \(j(1\leq j\leq d-d_{0})\), we apply \(L_{j}\) EdgeConv operations to \(F_{G}^{(j)}\) to obtain \(F_{G}^{(j+1)}\), and use shared MLPs to generate new bits \(b_{x}(d_{0}+j),b_{y}(d_{0}+j)\) for \(\mathbf{b_{x}},\mathbf{b_{y}}\), respectively. We regard stage \(j(1\leq j\leq d-d_{0})\) as refinement stage, since it refines the localization from the low-resolution grid \(S^{(d_{0}+j-1)}\) to the high-resolution one \(S^{(d_{0}+j)}\).

Compared with generating all bits at the network output layer, our progressive prediction enables image feature fusion at each refinement stage. As shown in Figure 2 (b), starting with the image feature map \(F_{I}^{(0)}\) with low spatial resolution \(2^{d_{0}}\times 2^{d_{0}}\), we use an additional CNN-based decoder to progressively generate image feature maps \(F_{I}^{(1)},\cdots,F_{I}^{(d-d_{0})}\) with increased spatial resolutions \(2^{d_{0}+1}\times 2^{d_{0}+1},\cdots,2^{d}\times 2^{d}\), respectively. We also add skip connections between the backbone and the decoder to recover the spatial information lost in \(F_{I}^{(0)}\). At the beginning of the refinement stage \(j\), our graph neural network generates the first \(d_{0}+j-1\) bits of \(\mathbf{b_{x}},\mathbf{b_{y}}\) for each keypoint \(P\), corresponding to the cell \(s_{P}^{(d_{0}+j-1)}\) in the grid \(S^{(d_{0}+j-1)}\). We then crop a local feature patch \(F_{I}^{(j)}\) centered at \(s_{P}^{(d_{0}+j-1)}\) from the image feature \(F_{I}^{(j)}\), and concatenate \(F_{I}^{(j)}\) with the keypoint embedding in the graph \(\mathcal{G}\). Since the initial keypoint embeddings \(F_{G}^{(0)}\) are obtained from \(F_{I}^{(0)}\), fusing the local image features in the refinement stages provides critical spatial information for fine-grained localization.

### Training

For the 1-bit indicator code \(\mathbf{b_{v}}\) of keypoint \(P\in\mathcal{P}\), our network output \(\hat{\mathbf{b}}_{\mathbf{v}}\) is the probability that \(\mathbf{b_{v}}=1\). We use binary cross-entropy loss for \(\mathbf{b_{v}}\) as below:

\[\mathcal{L}_{v}=\frac{1}{N}\sum_{P\in\mathcal{P}}\mathbf{b_{v}}\log\hat{ \mathbf{b}}_{\mathbf{v}}+(1-\mathbf{b_{v}})\log(1-\hat{\mathbf{b}}_{\mathbf{v }}), \tag{4}\]

where \(N\) is the number of the keypoints. For \(d\)-bit index codes \(\mathbf{b_{x}},\mathbf{b_{y}}\), since we only localize the keypoints inside the RoI (_i.e._, \(\mathbf{b_{v}}=1\)), denoted as \(\mathcal{P}_{I}\), we compute binary cross-entropy loss for each bit of \(\mathbf{b_{x}}\) as

\[\mathcal{L}_{x}=\frac{1}{dN_{I}}\sum_{P\in\mathcal{P}_{I}}\sum_{k =1}^{d}b_{x}(k)\log(\hat{b}_{x}(k))+\\ (1-b_{x}(k))\log(1-\hat{b}_{x}(k)), \tag{5}\]

where \(N_{I}\) is the number of keypoints inside the RoI, \(\hat{b}_{x}(k)\) is the network prediction for \(k\)-th bit of \(\mathbf{b_{x}}\). We compute the loss \(\mathcal{L}_{y}\) for \(\mathbf{b_{y}}\) in the same way as \(\mathcal{L}_{x}\).

Besides predicting the 2D projections as binary codes, we also enforce the network to output object segmentation masks. To do this, we apply a single CNN layer to the final image feature map \(F_{I}^{(d-d_{0})}\) and obtain a \(2\times 2^{d}\times 2^{d}\) output, which is served as the full segmentation mask \(M_{\mathrm{full}}\) and the visible one \(M_{\mathrm{vis}}\). We input the network predictions to the sigmoid function and apply \(L_{1}\) loss as the mask loss \(\mathcal{L}_{\mathrm{mask}}\). Generating the masks can be regarded as an auxiliary task to facilitate the learning of image features.

The overall loss function \(\mathcal{L}\) is a combination of \(\mathcal{L}_{v}\), \(\mathcal{L}_{x}\), \(\mathcal{L}_{y}\), and \(\mathcal{L}_{\mathrm{mask}}\) as

\[\mathcal{L}=\mathcal{L}_{v}+\mathcal{L}_{x}+\mathcal{L}_{y}+\mathcal{L}_{ \mathrm{mask}}. \tag{6}\]

Before training the whole network, we pretrain the layers that generate \(\mathbf{b_{v}}\) and the first \(d_{0}\) bits of \(\mathbf{b_{x}},\mathbf{b_{y}}\). This encourages the backbone network to quickly adapt to the object keypoints with smaller GPU memory usage, and makes the initial localization to be good for local image feature fusion in the refinement stages.

### Inference

During inference, we first discard the keypoints with \(\mathbf{b_{v}}=0\). Then we convert the binary codes to the corresponding cells in the final grid \(S\) (Eq. 1), and use the 2D coordinates of the cell centers as the keypoint projections. In this way, we establish dense 3D-2D correspondences from the network outputs without time-consuming computation operations, _e.g._, voting for the vector-field representations [49]. Finally we use the RANSAC/PnP [32] or Progressive-X [1] solvers to obtain the object pose from the dense 3D-2D correspondences.

We empirically find that for textureless objects with severe self-occlusions, discarding the correspondences outside \(M_{\mathrm{vis}}\) can improve the pose estimation results. To quantify the self-occlusions of a given object \(O\), we uniformly sample 2,562 camera viewpoints on a sphere, and use Hidden Point Removal (HPR) operator [27] to estimate the visibility of point \(P\in O\) from each viewpoint. We then calculate the proportion of the viewpoints for which \(P\) is visible, denoted as \(V(P)\). If \(0.2\leq V(P)<0.4\), then \(P\) is considered to be easily self-occluded. Note we ignore the points with \(V(P)<0.2\), to make our estimation robust to
the classification error of the HPR operator. The overall self-occlusion of the object \(O\) can be computed by

\[r_{\mathrm{so}}(O)=\frac{1}{|O|}\sum_{P\in O}\mathbb{1}(0.2\leq V(P)<0.4), \tag{7}\]

where \(|O|\) is the number of vertices of the object CAD model, and \(\mathbb{1}(\cdot)\) is the indicator function. If \(r_{\mathrm{so}}(O)\geq 0.5\), _i.e_., over half part of \(O\) is easily to be self-occluded, then we regard \(O\) as severely self-occluded.

## 4 Experiments

### Experimental Setup

Implementation Details.Our method is implemented using PyTorch [47] and trained using the Adam optimizer [29] with a batch size of 32. We pretrain our network for \(50,000\) steps with learning rate of 2e-4. For all experiments, we use \(N=512\) keypoints, and utilize \(k=20\) nearest neighbors to construct the \(k\)-NN graph \(\mathcal{G}\). For the binary code representation, we set \(d=6\) and \(d_{0}=3\). We resize the input RoIs to \(256\times 256\), and use HRNet [72] as our image feature backbone to extract \(1024\times 8\times 8\) feature map \(F_{I}^{(0)}\). Then we apply \(L_{0}=2\) EdgeConv operations to get \(\mathbf{b}_{\mathbf{v}}\) and the first \(d_{0}=3\) bits of \(\mathbf{b}_{\mathbf{x}},\mathbf{b}_{\mathbf{y}}\), and obtain the full binary codes after 3 refinement stages with \(L_{j}=3\) (\(j=1,2,3\)) EdgeConv operations.

Datasets.We conduct our experiments on three commonly-used datasets for object pose estimation: Linemod (LM) [17], Linemod-Occlusion (LM-O) [2], and YCB-V [75]. The LM dataset consists of 13 sequences of real images with ground truth poses for a single object with background clutter and mild occlusion. Each sequence contains around \(1,200\) images. Following [3], we utilize about \(15\%\) images for training while keeping the remaining ones for testing. We additionally use \(1,000\) synthetic RGB images for each object during training following [38, 71, 10]. The LM-O dataset consists of \(1,214\) images from a sequence of the LM dataset [17], where ground truth poses of eight objects with partial occlusion are annotated for testing. The YCB-V dataset is composed of more than \(110,000\) real images of \(21\) objects with severe occlusion and clutter. Apart from the real training images, we also utilize the physically-based rendered data following [19] for training on LM-O and YCB-V datasets.

Evaluation Metrics.We employ the common evaluation metric ADD(-S) for object pose estimation. The ADD(-S) metric measures whether the average distance between the model points transformed by the predicted pose and the ground truth is less than \(10\%\) of the object's diameter (0.1d), and for symmetric objects, ADD(-S) metric computes the deviation to the closest model point. On the YCB-V dataset, we also compute the AUC (area under curve) of ADD-S and ADD(-S) with a maximum threshold of 10 cm [75]. For LM dataset, we also report the \(n^{\circ},n\) cm metric, which measures the percentage of predicted 6D poses with rotation error below \(n^{\circ}\) and translation error below \(n\) cm. For symmetric objects \(n^{\circ},n\) cm computes the smallest error for all possible ground truth poses [37, 71].

### Ablation Study on LINEMOD Dataset

We present several ablation experiments on the LM dataset [17] in Table 1 to verify the effectiveness of each module. We train a single pose estimator for all objects for 120,000 steps, with a fixed learning rate of 1e-4 for the first 100,000 steps and a smaller learning rate of 5e-5 for the remaining steps. During inference, we utilize the detection results from Faster-RCNN [55] provided by [38]. We do not use any segmentation masks to filter the correspondences for fair comparison. Without specification, we use Progressive-X [1] to compute pose from the dense correspondences.

Comparison with State of the Art.As shown in Table 1, our method outperforms state-of-the-art approaches [71, 10, 7] w.r.t. ADD(-S) 0.05d, ADD(-S) 0.1d, and \(5^{\circ}5\)cm, and achieves comparable results w.r.t. ADD(-S) 0.02d and \(2^{\circ}2\)cm. The improvement of ADD(-S) 0.1d indicates that our method can facilitate the estimation of hard cases and serve as a good initialization for refinement methods [37, 26, 76]. Since the 2D coordinates of our estimated correspondences are approximated by the cell centers (Sec. 3.2), our pose estimation results in terms of ADD(-S) 0.02d may be further improved by increasing the resolution of the grid.
model the interactions between different keypoints. We also report the result of removing all GNN layers in Table 1. Without GNN layers, the keypoints still interact indirectly via local image feature fusion modules, since the keypoints with close 2D locations share the similar local image features. However, the performance of pose estimation degrades significantly, demonstrating that it is important to directly model the keypoint interactions with GNN layers.

**Effectiveness of Progressive Prediction.** Progressively generating the binary codes enforces our network to gradually refine the localization in the iteratively subdivided grids. It also enables image feature fusion based on the intermediate estimations, which can provide crucial spatial information for fine-grained localization. As shown in Table 1, the accuracy decreases significantly without progressively generating the binary codes, which clearly demonstrates the importance of progressive prediction.

**Effectiveness of Object Segmentation Masks.** Our network outputs the full segmentation mask \(M_{\text{full}}\) and the visible one \(M_{\text{vis}}\) as auxiliary tasks. As shown in Table 1, the performance degrades without either \(M_{\text{full}}\) or \(M_{\text{vis}}\). The ADD(-S) 0.02d metric drops significantly without \(M_{\text{full}}\), indicating that predicting \(M_{\text{full}}\) facilitates image feature extraction for keypoint localization, since all the keypoints should be located within \(M_{\text{full}}\). The degraded performance without \(M_{\text{vis}}\) also implies that predicting \(M_{\text{vis}}\) provides important context information including occlusions.

**Impact of Backbone Networks.** We report the results of our method with different backbone networks in Table 1. After replacing HRNet [72] by ResNet34 [15], our method still achieves comparable results with state of the art, which demonstrates the efficacy of our method regardless of the backbone networks.

**Influence of PnP Solvers.** We show the results with different PnP solvers during inference in Table 1. Since our correspondences are established from the binary codes, a small perturbation of our network prediction can result in flipped bit values, which may correspond to dramatically different locations in the input RoI. Compared with RANSAC/PnP [32], Progressive-X [1] contains a spatial coherence filter to efficiently remove such outliers, and thus achieves better performance w.r.t. to all the metrics, especially ADD(-S) 0.02d.

### Comparison to State of the Art

In this section we present the quantitative results of our method on LM-O and YCB-V datasets. We train a single CheckerPose for each object for 380,000 steps with a fixed learning rate of 1e-4. During inference, we utilize the detections from FCOS [65] provided by CDPNv2 [38].

**Experiments on the LM-O dataset.** We report the recall of ADD(-S) metric for the LM-O dataset in Table 2. Based on the criterion discussed in Sec. 3.5, we filter out the correspondences outside the visible segmentation masks \(M_{\text{vis}}\) for textureless objects with severe self-occlusions, including can, cat, driller, and eggbox. Without the filtering operation, the average recall of ADD(-S) of our method is 77.1, which surpasses previous methods. The detailed results of each object without filtering are provided in supplementary material. The additional filtering operation further improves the performance of our method. The intuition is that it is infrequent to observe an easily self-occluded keypoint \(P\) in the training images. Besides, due to the lack of texture, it is also hard to infer the location of \(P\) from other keypoints with distinguishable features. Such objects may require much more training steps to achieve stable estimations for easily self-occluded keypoints. Simply discarding correspondences outside \(M_{\text{vis}}\) reduces unstable localization results when our network is trained for limited steps, and enhances the robustness of pose estimation.

**Experiments on the YCB-Video dataset.** We report the averaged metrics of 21 objects in Table 3, and provide the detailed results in supplementary material. Based on the criterion discussed in Sec. 3.5, we use visible segmentation

\begin{table}
\begin{tabular}{c|c|c|c|c|c|c|c|c} \hline \hline Method & PVNet [49] & S. Stage [21] & Hybrid [58] & RePose [26] & GDR-Net [71] & SO-Pose [10] & Zebra [61] & Ours \\ \hline ape & 15.8 & 19.2 & 20.9 & 31.1 & 46.8 & 48.4 & 57.9 & 58.3 \\ can & 63.3 & 65.1 & 75.3 & 80.0 & 90.8 & 85.8 & 95.0 & 95.7 \\ cat & 16.7 & 18.9 & 24.9 & 25.6 & 40.5 & 32.7 & 60.6 & 62.3 \\ driller & 65.7 & 69.0 & 70.2 & 73.1 & 82.6 & 77.4 & 94.8 & 93.7 \\ duck & 25.2 & 25.3 & 27.9 & 43.0 & 46.9 & 48.9 & 64.5 & 69.9 \\ eggbox* & 50.2 & 52.0 & 52.4 & 51.7 & 54.2 & 52.4 & 70.9 & 70.0 \\ glue* & 49.6 & 51.4 & 53.8 & 54.3 & 75.8 & 78.3 & 88.7 & 86.4 \\ holep. & 36.1 & 45.6 & 54.2 & 53.6 & 60.1 & 75.3 & 83.0 & 83.8 \\ \hline mean & 40.8 & 43.3 & 47.5 & 51.6 & 62.2 & 62.3 & 76.9 & 77.5 \\ \hline \hline \end{tabular}
\end{table}
Table 2: **Comparison with State-of-the-art Methods on the LM-O Dataset.** We report the Average Recall (%) of ADD(-S). (*) denotes symmetric objects. We highlight the best result in red color, and the second best result in blue color.
masks to filter correspondences for foam_brick. We also apply the filtering operation to pudding_box because it is severely occluded by gelatin_box, which is a distraction object with similar texture. As shown in Table 3, CheckerPose achieves the best performance w.r.t. ADD(-S) and AUC of ADD(-S), and is comparable with state of the art w.r.t. AUC of ADD-S.

### Qualitative Results

In Figure 4, we provide localization results of eight keypoints for the occluded and flipped bowl. While our network directly outputs the 2D locations, the results of other dense methods [61, 71] are computed by projecting the keypoints using the estimated poses. Figure 4 (a) visualizes the reprojections of ZebraPose [61], where the keypoints concentrate on the visible pixels. Since ZebraPose generates pixel-wise 3D coordinates from the visible regions, it predicts a drastically wrong pose for the severely occluded bowl. As shown in Figure 4 (b), the reprojections of GDRNet [71] cover the region similar to the ground truth (Figure 4 (d)). However, the order of the blue keypoint and the red one changes from clockwise to counterclockwise, indicating the bowl is actually faced up. Since GDR-Net is an end-to-end method, it may memorize poses that frequently appear in the training samples. As shown in Figure 4 (c), our network is capable of localizing the keypoints for the upside-down object with severe occlusion. More qualitative results can be found in the Supplementary Material.

### Runtime Analysis

We test the running speed on the LM-O dataset. Given a \(640\times 480\) RGB image, we evaluate the speed of our method on a desktop with an Intel 3.30GHz CPU and an NVIDIA GeForce GTX 1080 GPU (8G). The FCOS detector [65] takes 87 ms for each image. The runtime of establishing the dense 3D-2D correspondences by our network is 78 ms. RANSAC/PnP [32] takes only 1 ms to recover pose from the correspondences, while Progressive-X [1] takes 32 ms.

## 5 Conclusion

In this work, we propose a novel way to establish dense correspondences for object pose estimation, by progressively localizing dense 3D keypoints in the input image. With dense keypoints including occluded and self-occluded ones, we comprehensively explore the available geometry information and enhance the robustness of pose estimation under severe occlusion. We adopt graph neural networks to explicitly model the keypoint interactions, and design a hierarchical binary code representation for the 2D locations. The experiments on LM, LM-O and YCB-V datasets demonstrate that our method achieves state-of-the-art performance of instance-level object pose estimation.

Figure 4: **Visualization of keypoint localization. (a) Keypoint locations based on the predicted pose of ZebraPose [61]. (b) Keypoint locations based on the pose estimated by GDR-Net [71]. (c) Keypoint locations output by our network. (d) The ground truth keypoint locations. Considering the symmetry of the bowl, we use the equivalent rotations closest to our prediction to project the keypoints in (a), (b), and (d).**

\begin{table}
\begin{tabular}{l|c|c|c} \hline \hline Method & ADD(-S) & \begin{tabular}{c} AUC \\ ADD-S \\ \end{tabular} & \begin{tabular}{c} AUC \\ ADD-S \\ \end{tabular} & 
\begin{tabular}{c} AUC \\ ADD(-S) \\ \end{tabular} \\ \hline SegDriven [22] & 39.0 & – & – \\ SingleStage [21] & 53.9 & – & – \\ CosyPose [31] & – & 89.8 & 84.5 \\ RePose [26] & 62.1 & 88.5 & 82.0 \\ GDR-Net [71] & 60.1 & 91.6 & 84.4 \\ SO-Pose [10] & 56.8 & 90.9 & 83.9 \\ ZebraPose [61] & 80.5 & 90.1 & 85.3 \\ DProST [45] & 65.1 & – & 77.4 \\ CheckerPose (Ours) & 81.4 & 91.3 & 86.4 \\ \hline \hline \end{tabular}
\end{table}
Table 3: **Comparison with State-of-the-art Methods on the YCB-Video Dataset. We report the ADD(-S), and AUC of ADD-S and ADD(-S). Following [75], the symmetric metric is used for all objects in ADD-S while only for symmetric objects in ADD(-S). We highlight the best result in red color, and the second best result in blue color. “–” denotes unavailable results.**