{'fraction_non_alphanumeric': 0.030527793492153288, 'fraction_numerical': 0.015525803004588598, 'mean_word_length': 4.455875628715135, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Single-view robot pose and joint angle estimation via render&compare

We introduce RoboPose, a method to estimate the joint angles and the 6D camera-to-robot pose of a known articulated robot from a single RGB image. This is an important problem to grant mobile and itinerant autonomous systems the ability to interact with other robots using only visual information in non-instrumented environments, especially in the context of collaborative robotics. It is also challenging because robots have many degrees of freedom and an infinite space of possible configurations that often result in self-occlusions and depth ambiguities when imaged by a single camera. The contributions of this work are three-fold. First, we introduce a new render&compare approach for estimating the 6D pose and joint angles of an articulated robot that can be trained from synthetic data, generalizes to new unseen robot configurations at test time, and can be applied to a variety of robots. Second, we experimentally demonstrate the importance of the robot parametrization for the iterative pose updates and design a parametrization strategy that is independent of the robot structure. Finally, we show experimental results on existing benchmark datasets for four different robots and demonstrate that our method significantly outperforms the state of the art. Code and pre-trained models are available on the project webpage https://www.di.ens.fr/willow/research/robopose/.


Introduction
The goal of this work is to recover the state of a known articulated robot within a 3D scene using a single RGB image. The robot state is defined by (i) its 6D pose, i.e. a 3D translation and a 3D rotation with respect to the camera frame, and (ii) the joint angle values of the robot's articulations. The problem set-up is illustrated in Figure 1. This is an important problem to grant mobile and itinerant autonomous systems the ability to interact with other robots using only visual information in non-instrumented environments. For instance, in the context of collaborative tasks between two or more robots, having knowledge of the pose and the joint angle articulated robot in an unknown configuration (left), RoboPose estimates the joint angles and the 6D camera-to-robot pose (rigid translation and rotation) providing the complete state of the robot within the 3D scene, here illustrated by overlaying the articulated CAD model of the robot over the input image (right). (b) When the joint angles are known at test-time (e.g. from internal measurements of the robot), RoboPose can use them as an additional input to estimate the 6D camera-to-robot pose to enable, for example, visually guided manipulation without fiducial markers.
values of all other robots would allow better distribution of the load between robots involved in the task [5].
The problem is, however, very challenging because robots can have many degrees of freedom (DoF) and an infinite space of admissible configurations that often result in selfocclusions and depth ambiguities when imaged by a single camera. The current best performing methods for this problem [28,63] use a deep neural network to localize in the image a fixed number of pre-defined keypoints (typically located at the articulations) and then solve a 2D-to-3D optimization problem to recover the robot 6D pose [28] or pose and configuration [63]. For rigid objects, however, methods based on 2D keypoints [34,3,7,6,46,53,24,51,45,44,19] have been recently outperformed by render & compare methods that forgo explicit detection of 2D keypoints but instead use the entire shape of the object by comparing the rendered view of the 3D model to the input image and iteratively refining the object's 6D pose [46,60,31,26]. Motivated by this success, we investigate how to extend the render & compare paradigm for articulated objects. This presents significant challenges. First, we need to estimate many more degrees of freedom than the sole 6D pose. Articulated robots we consider in this work can have up to 15 degrees of freedom in addition to their 6D rigid pose in the environment. Second, the space of configurations is continuous and hence there are infinitely many configurations in which the object can appear. As a result, it is not possible to see all configurations during training and the method has to generalize to unseen configurations at test time. Third, the choice of transformation parametrization plays an important role for 6D pose estimation of rigid objects [31] and finding a good parametrization of pose updates for articulated objects is a key technical challenge.
Contributions. To address these challenges, we make the following contributions. First, we introduce a new render & compare approach for estimating the 6D pose and joint angles of an articulated robot that can be trained from synthetic data, generalizes to new unseen robot configurations at test time, and can be applied to a large variety of robots (robotic arms, bi-manual robots, etc.). Second, we experimentally demonstrate the importance of the robot pose parametrization for the iterative pose updates and design an effective parametrization strategy that is independent of the robot. Third, we apply the proposed method in two settings: (i) with known joint angles (e.g. provided by internal measurements from the robot such as joint encoders), only predicting the camera-to-robot 6D pose, and (ii) with unknown joint angles, predicting both the joint angles and the camera-to-robot 6D pose. We show experimental results on existing benchmark datasets for both settings that include a total of four different robots and demonstrate significant improvements compared to the state of the art.

Related work
6D pose estimation of rigid objects from RGB images [47,33,34] is one of the oldest problems in computer vision. It has been successfully approached by estimating the pose from 2D-3D correspondences obtained via local invariant features [34,3,7,6], or by templatematching [15]. Both these strategies have been revisited using convolutional neural networks (CNNs). A set of sparse [46,53,24,51,45,44,19] or dense [57,42,50,60] features is detected on the object in the image using a CNN and the resulting 2D-to-3D correspondences are used to recover the camera pose using PnP [29]. The best performing methods for 6D pose estimation from RGB images are now based on variants of the render & compare strategy [38,46,31,35,39,26,60] and are approaching the accuracy of methods using depth as input [17,16,31,26]. Hand-eye calibration (HEC) [18,14] methods recover the 6D pose of the camera with respect to a robot. The most common approach is to detect in the image fiducial markers [10,9,40] placed on the robot at known positions. The resulting 3D-to-2D correspondences are then used to recover the camera-to-robot pose using known joint angles and the kinematic description of the robot by solving an optimization problem [41,20,58]. Recent works have explored using CNNs [27,28] to perform this task by recognizing 2D keypoints at specific robot parts and using the resulting 3Dto-2D correspondences to recover the hand-eye calibration via PnP. The most recent work in this direction [28] demonstrated that such learning-based approach could replace more standard hand-eye calibration methods [55] to perform online calibration and object manipulation [54]. Our render & compare method significantly outperforms [28] and we also demonstrate that our method can achieve a competitive accuracy without requiring known joint angles at test time. Depth-based pose estimation of articulated objects. Previous work on this problem can be split into three classes. The first class of methods aims at discovering properties of the kinematic chain through active manipulation [22,23,12,36] using depth as input and unlike our approach cannot be applied to a single image. The second class of methods aims at recovering all parameters of the kinematic chain from a single RGBD image, including the joint angles, without knowing the specific articulated object [30,59,2,61]. In contrast, we focus on the set-up with a known 3D model, e.g. a specific type of a robot. The third class of methods, which is closest to our set-up, considers pose and joint angle estimation [37,8,43] for known articulated objects but relies on depth as input and only considers relatively simple kinematic chains such as laptops or drawers where the joint parameters only affect the pose of one part. Others recover joint angles of a known articulated robot part [4,56] but do not recover the 6D pose of the camera and also rely on depth. In contrast, our method accurately estimates the pose and joint angles of a robotic arm with many degrees of freedom from a single RGB image. Robot pose and joint angle estimation from an RGB image. To the best of our knowledge, only [63] has addressed a scenario similar to us where the robot pose and joint angles are estimated together from a single RGB image. A set of predefined 2D keypoints is recognized in the image and the 6D pose and joint angles are then recovered by solving a nonlinear non-convex optimization problem. Results are shown on a 4 DoF robotic arm. In contrast, we describe a new render & compare approach for this problem, demonstrate significantly improvements in 3D accuracy and show results on robots with up to 15 DoF.

Approach
We present our render & compare framework to recover the state of a robot within a 3D scene given a single RGB image. We assume the camera intrinsic parameters, the CAD model and kinematic description of the robot are known. We start by formalizing the problem in Section 3.1. We then present an overview of our approach in Section 3.2 and explain our training in Section 3.3. Finally, we detail the key choices in the problem parametrization in Section 3.4.

Problem formalization
Our notations are summarized in Figure 2. We consider a known robot composed of rigid parts P 0 ,...,P N whose 3D models are known. An articulation, or joint, connects a parent part to a child part. Given the joint angle q i of the i-th joint, we can retrieve the relative 6D transformation between the parent and child reference frames. Note that for simplicity we only consider revolute joints, i.e. joints parametrized by a single scalar angle of rotation q i , but our method is not specific to this type of joints. The rigid parts and the joints define the kinematic tree of the robot. This kinematic description can be used to compute the relative 6D pose between any two parts of the robot. In robotics, the full state of a robot S is defined by the joint angles and the 6D pose of the root of the kinematic tree. Defining the 6D pose of the robot with respect to the root (whose pose is independent of the joint angles since it is not a child of any joint) is a crucial choice in the parametrization of the problem, but also arbitrary, since an equivalent kinematic tree could be defined using any part as the root. We instead define the full state of the robot by (i) the selection of an anchor part P a , (ii) the 6D pose of the anchor with respect to the camera T C,a , and (iii) the joint angles q = (q 1 , ..., q D ) ∈ R D , where D is the number of joints. Note the anchor part can change across iterations of our approach. We discuss the choice of the anchor in Section 3.4 and experimentally demonstrate it has an important influence on the results.

Render & compare for robot state estimation
We now present our iterative deep render & compare framework, illustrated in Figure 3. We iteratively refine the state estimate as follows. First, given a current estimate of the state S k we render an RGB image of the robot R(S k ) and the mask of the anchor part. We then apply a deep refiner network that takes as input crops of the rendered image and the input RGB image I of the scene. It outputs a new state of the robot S k+1 = f θ (S k , I) to attempt to match the ground truth state S gt of the observed robot. Unlike prior works that have used render & compare strategies for estimating the 6D pose of rigid objects [31,60,26], our method does not require a coarse pose estimate as initialization.
Image rendering and cropping. To render the image of the robot we use a fixed focal length (defining an intrinsic camera matrix) during training. The rendering is fully defined by the state of the robot and the camera matrix. Instead of giving to the refiner network the full image and the rendered view, we focus the inputs on the robot by cropping the images as follows. We project the centroid of the rendered robot in the image, consider the smallest bounding box of aspect ratio 4/3 centered on this point that encloses the projected robot and increase its size by 40% (see details in the appendix). This crop depends on the projection of the robot to the input image that varies during training, and thus provides an augmentation of the effective focal length of the virtual cropped cameras. Hence, our method can be applied to cameras with different intrinsics at test time as we show in our experiments.
Initialization. We initialize the robot to a state S 0 defined by the joint configuration q 0 and the pose T 0 C,a of the anchor part a with respect to the camera C. At training time we define S 0 using perturbations of the ground truth state. At test time we initialize the joints to the middle of the joint limits, and the initial pose T 0 C,a so that the frame of the robot base is aligned with the camera frame and the 2D bounding box defined by the projection of the robot model approximately matches the size of image. More details are given in the appendix.
Refiner and state update. At iteration k, the refiner predicts an update ∆q k of the joint angles q k (composed of one scalar angle per joint), such that Figure 3: RoboPose overview. Given a single input RGB image, the state S (6D camera-to-robot pose and joint angles) of the robot is iteratively updated using renderer and refiner modules to match the input image. The refinement module takes as input the cropped observed image and a rendering of the robot as well as the mask of an anchor part. The anchor part is used for updating the rigid 6D pose of the robot while the rest of the parts are updated by changing their joint angles. Note that the anchor part is changing across iterations making the refinement more robust.
and an update ∆T k of the current 6D pose T k C,a of the anchor part, such that where we follow DeepIM [31]'s parametrization for pose update ∆T k . This parametrization disentangles rotation and translation prediction but crucially depends on the choice of a reference point we call O. In DeepIM this point is simply taken as the center of the reference frame of the rigid object but there is not such a natural choice of reference point for articulated objects, which have multiple moving parts. We discuss several possible choices of the reference point O in Sec. 3.4 and demonstrate experimentally it has an important impact on the results. In particular, we show that naively selecting the reference frame of the root part is sub-optimal.

Training
In the following, we describe our loss function, synthetic training data, implementation details and discuss how to best use known joint angles if available. Loss function. We train our refiner network using the following loss: where θ are the parameters of the refiner network, K is the maximum number of iterations of the refinement algorithm, T gt C,a is the ground truth 6D pose of the anchor, q gt are the ground truth joint angles and λ is a hyper-parameter to balance between the 6D pose loss L a and the joint angle loss L q . The 6D pose loss L a measures the distance between the predicted 3D point cloud obtained using T k C,a transformed with ∆T k and the ground truth 3D point cloud (obtained using T gt C,a ) of the anchor P a . We use the same loss as [26] that disentangles rotation, depth and image-plane translations [49] (see equations in the appendix). For L q , we use a simple L 2 regression loss, L q = q k + ∆q k − q gt 2 2 .
Note that the 6D pose loss is measured only on the anchor part a while the alignment of the other parts of the robot is measured by the error on their joint angles (rather than alignment of their 3D point clouds). This disentangles the 6D pose loss L a from the joint angle loss L q and we found this leads to better convergence. We sum the loss over the refinement iterations k to imitate how the refinement algorithm is applied at test time but the error gradients are not backpropagated through rendering and iterations. Finally, for simplicity the loss (3) is written for a single training example, but we sum it over all examples in the training set.
Training data. For training the refiner, we use existing datasets [28,63] provided by prior works for the Kuka, Panda, Baxter, OWI-535 robots. All of these datasets are synthetic, generated using similar procedures based on domain randomization [52,32,48,21]. The joint angles are sampled independently and uniformly within their bounds, without assuming further knowledge about their test time distribution. We add data augmentation similar to [26].
We sample the initial state S 0 by adding noise to the ground truth state in order to simulate errors of the network prediction at the previous state of the refinement as well as the error at the initalization. For the pose, we sample a translation from a centered Gaussian distribution with standard deviation of 10 cm, and a rotation by sampling three angles from a centered Gaussian distribution of standard deviation 60 • . For the joint angles, we sample an additive noise from a centered Gaussian distribution with a standard deviation equal to 5% of the joint range of motion, which is around 20 • for most of the joints of the robots we considered.
Implementation details. We train separate networks for each robot. We use a standard ResNet-34 architecture [13] as the backbone of the deep refiner. The hyper-parameters are λ = 1 and K = 3 training iterations. Note that at test time we can perform more iterations, and the results we report correspond to 10 iterations. The anchor is sampled randomly among the 5 largest parts of the robot at each iteration. This choice is motivated in Section 3.4 and other choices are considered in the experiments, Section 4.3. We initialize the network parameters randomly and perform the optimization using Adam [25], with the procedure described in the appendix for all the networks.
Known joint angles at test time. The approach described previously could be used at test time with measured joint angles q 0 = q gt and by ignoring the joint update, but we observed better results by training a separate network which only predicts a pose update for this scenario. In this context where the joint values are known and constant, the full robot is considered as a single and unique anchor. Yet, the problem remains different from classic rigid object 6D object pose estimation because the network must generalize to new joint configurations unseen during training.

Parametrization choices
There are two main parametrization choices in our approach: (i) the choice of the reference point O for the parametrization of the pose update ∆T k in equation (2) and (ii) the choice of the anchor part to update the 6D pose and measure pose loss in equation (3). These choices have a significant impact on the results, as shown in Section 4.
Choice of the reference point for the pose update. Similar to [31], we parametrize the pose update as a rotation around a reference point O and a translation defined as a function of the position of O with respect to the camera. The fact that the rotation is around O is a first obvious influence of this choice on the transformation that needs to be predicted. The impact on the translation update parameters is more complicated: they are defined by a multiplicative update on the depth of O and by an equivalent update in pixels in the image, which is also related to the real update by the depth of O (see equations in the appendix).
A seemingly natural choice for reference point O would be a physical point on the robot, for example the center of the base of the robot or the anchor part. However, on the contrary to the rigid object case, if that part is not visible or is partially occluded, the network cannot infer the position of the reference O precisely, and thus cannot predict a relevant translation and rotation update. In experiments, we show it is better to use as O the centroid of the estimated robot state, which takes into account the estimated joint configuration, and can be more reliably estimated.
Choice of the anchor part. The impact of the choice of the anchor part P a used for computing the 6D pose loss in equation (3), is illustrated in Figure 4. We explore several choices of anchor part in our experiments, and show that this choice has a significant impact on the results. Since the optimal choice depends on the robot, and the observed pose, we introduce a strategy where we randomly select the anchor among the largest parts of the robot, during both training and refinement, and show that on average it performs similarly or slightly better than the optimal oracle choice of a single unique anchor on the test set.

Experiments
We evaluate our method on recent benchmarks for the following two tasks: (i) camera-to-robot 6D pose estimation for three widely used manipulators (Kuka iiwa7, Rethink robotic Baxter, Franka Emika Panda) [28], and (ii) full state estimation of the low-cost 4 DoF robotic arm OWI-535 [63]. In Section 4.1, we consider the first task, where an image of a robot with fixed known joint angles is used to estimate the 6D camera-to-robot pose. We show that our approach outperforms the state-of-the-art DREAM method [28]. In Section 4.2, we evaluate our full approach where both the 6D pose and joint angles are unknown. We show our method outperforms the state-of-the-art method [63] for this problem on their dataset depicting the low-cost 4 DoF robot and that it can recover the 6D pose and joint angles of more complex robotic manipulators. Finally, Section 4.3 analyzes the parametrization choices discussed in Section 3.4.

6D pose estimation with known joint angles
Datasets and metrics. We focus on the datasets annotated with 6D pose and joint angle measurements recently introduced by the state-of-the-art method for single-view camerato-robot calibration, DREAM [28]. We use the provided training datasets with 100k images generated with domain  Table 1: Comparison of RoboPose (ours) with the state-of-the-art approach DREAM [28] for the camera-to-robot 6D pose estimation task using the 3D reconstruction ADD metric (higher is better). The robot joint configuration is assumed to be known (results in black) and is different in each of the image in the dataset, but the pose of the camera with respect to the robot can be fixed (# number of 6D poses We use the 3D reconstruction ADD metric which directly measures the pose estimation accuracy, comparing distances between 3D keypoints defined at joint locations of the robot in the ground truth and predicted pose. We refer to the appendix for exact details on the evaluation protocol of our comparison with DREAM [28]. Comparison with DREAM [28]. We train one network for each robot using the same synthetic datasets as [28] and report our results in Table 1. Our method achieves significant improvements across datasets and robots except on Panda 3CAM-RS where the performance of [28] with ResNet101-H variant is similar to ours. On the Panda 3CAM-AK and Panda 3CAM-XK datasets, the performance of our method is significantly higher than the ResNet101-H model of [28] (e.g. +21.96 on 3CAM-XK), which suggests that the approach of [28] based on 2D keypoints is more sensitive to some viewpoints or camera parameters. Note that our method trained with the synthetic GL camera can be applied to different real cameras with different intrinsics at test time thanks to our cropping strategy which provides an augmentation of the effective focal length during training.
On Panda-ORB, the largest real dataset that covers multiple camera viewpoints, our method achieves a large improvement of 11.5 points. Our performance on the synthetic datasets for the Kuka and Baxter robots is also significantly higher than [28]. We believe the main reason for this large  improvements is the fact that our Render & Compare approach can directly use the shape of the entire robot rendered in the observed configuration for estimating the pose rather than detecting a small number of keypoints. Running time. In Table 2 we report the running time of our method on the Panda-ORB dataset which consists of robot motion videos captured from 27 different viewpoints. The first observation is that the accuracy increases with the number of refinement iterations K used at test-time, and the most significant improvements are during the first 3 iterations. The importance of using multiple network iterations during training is further discussed in the appendix. We also report an online version of our approach that leverages temporal continuity. It runs the refiner with K = 10 iterations on the first frame of the video and then uses the output pose as the initialization for the next frame and so on, without any additional temporal filtering of the resulting 6D poses. This version runs at 16 frames per second (FPS) and achieves a similar performance as the full approach that considers each frame independently and runs at 1 FPS.

6D pose and joint angle estimation
We now evaluate the performance of our method in the more challenging scenario where the robot joint angles are unknown and need to be estimated jointly with the 6D pose   Table 3: Results on the CRAVES-lab [63] dataset with unknown joint angles. We report average errors on all the images of the dataset, or on the top 50% images selected according to the best joint angle accuracy with respect to the ground truth. Networks are trained on synthetic data only (synt) or also using non-annotated real images of the robot (synt+real*). from a single RGB image. Qualitative results on the considered datasets as well as on real images crawled from the web are shown in Figure 5. Please see the appendix for additional qualitative examples, and the project page [1] for a movie showing our predictions on several videos.
Comparison with CRAVES [63]. CRAVES [63] is the state-of-the-art approach for this task. We consider the two datasets used in [63]. CRAVES-lab displays the OWI-535 4DoF in a lab environment and contains 20,000 RGB images of which 428 key frames are annotated with 2D robot keypoints, ground truth joint angles (not used by our method) and camera intrinsics. CRAVES-youtube is the second dataset containing real-world images crawled from YouTube depicting large variations in viewpoint, illumination conditions and robot appearance. It contains 275 frames annotated with 2D keypoints but no camera intrinsic param-  eters, 6D pose or joint angle ground truth. In addition to metrics that measure the 6D pose and joint angle estimates, we report a 2D keypoint metric, PCK (percentage of keypoints), following [63]. We refer to the appendix for details of the metrics and the evaluation protocol. We compare with two variants of CRAVES, one trained only on synthetic images (synt), and one that also requires real non-annotated images (synt+real*). Our method is trained only using the 5, 000 provided synthetic images. We report results on CRAVES-lab in Table 3. To compare with the 2D keypoint metric PCK@0.2, we project in the image the 3D keypoints of our estimated robot state. On this metric, our method outperforms CRAVES trained only on synthetic images and achieves a near-perfect score, similar to their approach trained with real images. More importantly, we achieve much better results when comparing with the 3D metrics (joint angles error and translation/rotation error). CRAVES achieves high average errors when all images of the datasets are considered, which is due to the complexity of solving the nonlinear nonconvex 2D-to-3D optimization problem for recovering 6D pose and joint angles given 2D keypoint positions. Our method trained to directly predict the 6D pose and joint angles, achieves large improvements in precision. We reduce the translation error by a factor of 10, demonstrating robustness to depth ambiguities.
We also evaluated our method on CRAVES-youtube. On  this dataset, the camera intrinisic parameters are unknown and cannot be used for projecting the estimated robot pose into the 2D image. We therefore report results for different hypothesis of (fixed) focal lengths for all the images of the dataset, as well as using an oracle (f=best) which selects the best focal length for each image. Results are reported in Table 4. For 2D keypoints, our method for f = 1000 achieves results superior to CRAVES while not requiring real training images. Our method also clearly outperforms CRAVES when selecting the best focal length. 3D ground truth is not available, but similar to CRAVES-lab we could expect large improvements in 3D accuracy. Experiments on 7DoF+ robots. We also train our method for jointly predicting 6D pose and joint angles for the robots considered in Section 4.1. We evaluate the 6D pose and joint angles accuracy using ADD. Results are reported in Table 1 in blue (last column). For the 7DoF robotic arms (Kuka and Panda), these results demonstrate a competitive or superior ADD accuracy compared to [28] for inferring the 3D geometry of a known robot, but our method does not require known joint angles. The more complex 15 DoF Baxter robot remains challenging although our qualitative results often show reasonable alignments. We discuss the failure modes of our approach in the appendix.

Analysis of parametrization choices
We analyze our method on the Panda-ORB dataset: it is the largest real dataset containing significant variations in joint angles and camera viewpoints and the Panda robot has a long kinematic chain with 8 DoF. We study the choice of reference point O for the 6D pose update and the choice of the anchor part (see Section 3.4). Reference point. We train different networks with the reference point at the origin of the root P 0 , the part in the middle of the kinematic chain P 4 and at the end of the kinematic chain P 7 . Results are reported in Table 5(a). We observe that the performance indeed depends on the choice of the reference point and our approach of using the centroid of the robot as the reference point performs the best. The  network trained with the "Hand" part (P 7 , the end effector) as a reference point fails to converge because this part is often difficult to identify in the training images and its pose cannot be inferred from any other part because the robot is not a rigid object. We investigate picking the reference point on one of the five largest parts (measured by their 3D volume which is correlated with 2D visibility) in Table 5(b) again demonstrating our approach of using the centroid of the robot performs better than any of these specific parts.
Choice of the anchor part. Table 6 reports results using different strategies for chosing the anchor part during training and testing. First, in 6(a) we show that choosing different parts as one (fixed) anchor results in significant variation in the resulting performance. To mitigate this issue we consider in 6(b) a strategy where the anchor is picked randomly among the robot parts at each iteration (both during training and testing). This strategy performs better than always naively selecting the root P 0 as anchor. By restricting the sampled anchors to the largest parts, our automatic strategy can also perform better than the best performing part P 4 .

Conclusion
We have introduced a new render & compare approach to estimate the joint angles and the 6D camera-to-robot pose of an articulated robot from a single image demonstrating significant improvements over prior state-of-the-art for this problem. These results open-up exciting applications in visually guided manipulation or collaborative robotics without fiducial markers or time-consuming hand-eye calibration. To stimulate these applications, we released the training code as well as the pre-trained models for commonly used robots.
Acknowledgments. This work was partially supported by the HPC resources from GENCI-IDRIS (Grant 011011181R1), the European Regional Development as introduced in Section 3.2 in the main paper. In the following we present the equations that define this pose update. We follow the parametrization of DeepIM's [31] pose update and explicitly parametrize the pose update using a 3D reference point we call O k . We choose to use the centroid of the estimated robot at the k-th iteration as O k , but other choices are also possible. Our neural network refiner predicts parameters v x , v y , v z that are used to compute the 3D translation ∆t. The refiner also predicts the 3D rotation ∆R that together with ∆t define the pose update ∆T in (4). The parameters v x and v y correspond to the displacement in the image plane (in pixels) of the reference point O k at iteration k and v z corresponds to a relative update of the depth of O k , again relative to the camera coordinate system: where From these equations, we can derive the update of the 3D translation of the 3D point O k : with the x, y and z components of translation update ∆t O k defined as : Note that ∆t O k depends on the 3D point O k . Hence the network has to learn to internally infer this point to predict consistent transformation updates. The rotation update ∆R (parametrized by three angles) predicted by the refiner network is applied around the 3D reference point O k . This defines the transformation of any 3D point on the anchor. Let's consider a point a on the anchor part in position t k a at iteration k, its position at iteration k + 1 is given by: where ∆R is the rotation matrix predicted by the network using the same rotation parametrization used in [26,62]. The equation (12) can also be used to define the rotation matrix of the anchor part with respect to the camera: where R k C,a defines the rotation of the anchor part with respect to the camera before the pose update, R k+1 C,a defines the rotation of the anchor part with respect to the camera after the pose update and ∆R is the rotation matrix predicted by the network. The equations (12) and (13) fully define the pose update given by equation (4) as a function of the network predictions v x , v y , v z and ∆R, and the reference point O k . For computing the loss in the next section, we write the pose T k+1 C,a of the anchor part a in the camera coordinate system C at iteration k + 1 (after the pose update) as where U expresses the updated pose of the anchor as a function of all network predictions v x , v y , v z , ∆R, and can be computed in a closed form using the equations derived above.

B. Pose loss
We define the following distance D a (T 1 , T 2 ) to measure the distance between two transformations T 1 and T 2 using the 3D points X a on the anchor part a : where | · | is the L 1 norm. The pose loss L a in equation (3) in the main paper follows [26] and is written as: where U defines the pose update as explained in (14) in Section A,T C,A is the ground truth 6D pose of the anchor with repect to the camera, v x , v y , v z , ∆R are the parameters of the pose update predicted by the network, andv x ,v y ,v z , ∆R are the values of these updates that would lead to the ground truth pose. The different terms of this loss separate (or disentangle) the influence of different subsets of parameters on the loss. In detail, the first term (16)

C. Cropping strategy
be the 2D projection of the 3D centroid O of the robot by the camera with intrinsics K. We use a cropping strategy similar to DeepIM but using only the projection of the 3D points of the model in the current pose estimate to define the bounding box of the crop. Let u 1 = (u 1,x , u 1,y ), u 2 = (u 2,x , u 2,y ) be the coordinates of the upper left and lower right corners of the bounding box defined by the robot projection in the image, respectively. We define: where u dist,y = max(|u 1,y − u O,y |, |u 2,y − u O,y |), (22) r = 4/3 is the aspect ratio of the crop and λ = 1.4 following DeepIM [31]. The crop is centered at u O , of width ∆u x and height ∆u y . An example of a crop is given in Figure 6.

D. State initialization
Let u det = (u det,x , u det,y ) and (∆u det = ∆u det,x , ∆u det,y ) define the center and the size of the approximate 2D bounding box of the robot in the image. In our experiments, there is only one robot per image and thus we use the entire image as the 2D bounding box and denote the bounding box u det . The orientation of the base of the robot P 0 is set parallel to the axes of the camera with the z axis pointing upwards. The centroid of the robot O is set to match the center of the bounding box u det . We make the first hypothesis of the depth of the centroid by setting z guess C,O = 1m and use this initial value to estimate the coordinates x and y of the centroid in the camera frame: y guess C,O = u det,y z guess We then update the depth estimate z guess C,O using the following simple strategy. We project the points of the robot using the initial guess we have just defined. These points define a bounding box with dimensions ∆u guess,x = (∆u guess,x , ∆u guess,y ) and the center remains unchanged u guess = u det by construction. We compute an updated depth of the centroid such that its width and height approximately match the size of the 2D detection: and use this new depth to compute x 0 C,O and y 0 C,O using equations (23) and (24)  where q + and q − define the interval of the robot articulation angles. An example of initialization is shown in Figure 7.
In the experiments of Section 4 of the main paper, we use the entire image as the 2D bounding box because the test images show a single robot. Please note however that it would be straightforward to process multiple bounding boxes like [26] for multiple rigid objects. If multiple robots are in the input bounding box (e.g. as in some of the examples in the results video on the project webpage [1]), our iterative refinement typically converges to the largest robot in the image.

E. Training strategy
The training of the neural networks is performed with Adam [25] using a learning rate of 0.003 and batches of 1408 images, split on 44 GPUs. The networks are trained for 60k iterations. Following recommendations from [11] for distributed training, we use a warm up-phase: the learning rate is linearly increased from to 0. to 0.003 during the first 5k iterations. The learning rate is reduced to 0.0003 at 45k iterations. In order to speed up the training, we start by training with K = 1 refinement iterations and add other iterations K = 2, K = 3 at 15k and 30k iterations respectively. We found that starting to train with K = 1 and increasing the number of refinement iterations during training has no effect on the results, but allows to train the refiner network faster.

F. Evaluation details
Next, we give more details about the evaluation metric and the evaluation protocol of our comparison with DREAM [28] and CRAVES [63].

F.1. Comparison with DREAM
The average distance (ADD) metric measures the distance between 3D keypoints on the robot transformed with the pre-  dicted and ground truth 6D poses. The 3D keypoints are the same as in [28] for the Kuka, Panda and Baxter robots and are defined at the locations of robot joints. The ADD errors of the 3D keypoints for the robot depicted in the image are averaged, and we report the area-under-the-curve of the ADD pass rate vs. threshold following [28]. We refer to [28,57] for more details about this metric. A slight difference with the evaluation protocol of [28] is that all images are considered as possible evaluation targets, whereas [28] discards images where there are fewer than 4 robot keypoints visible in the ground truth because PnP cannot be solved in this situation. This favors methods that rely on keypoints and does not fully consider the difficulty of estimating the pose of robots in situations with high self-occlusions, a situation that our method can handle. We thus evaluate ADD on all images, even those with fewer than four visible robot keypoints. The models from DREAM [28] were re-evaluated with this protocol and in practice the difference is only minor compared to the results reported in DREAM [28], less than 2% for all datasets. For reproducing DREAM results reported in Table 1 of the main paper, we used the provided code and pre-trained models 1 using the instructions to reproduce the results from the paper, e.g. using the "shrink-and-crop" cropping strategy. Note that while evaluating these models, we found some results to be higher than reported in the original paper, e.g. the ResNet101-H is the best model on the largest real dataset Panda-ORB (69.05) but only the VGG19-F (61.93) was reported in [28]. We reported results for all models of DREAM [28] in Table 1 of the main paper.
When evaluating our method that predicts joint angles, ADD is computed using 3D keypoints on the robot that are computed using both the estimated 6D pose and the predicted joint angles using the robot forward kinematics. This provides a principled way to measure the accuracy of the 3D reconstruction of the robot without giving arbitrary weights to rotation, translation or joint angle errors.

F.2. Comparison with CRAVES
For the comparison with CRAVES [63], we based our evaluation on the code provided with the paper 2 . The 3D metrics reported in Table 3 for CRAVES-lab are:

G. Benefits of the iterative formulation
In this section, we investigate the benefits of the number of refiner iterations at training and test time. In the following, we denote as K train the number of refiner network iterations used during training (denoted K in equation (3) of the main paper) and as K test the number of iterations used at test time. We experimentally evaluate the influence of K train and K test using the ADD metric on the Panda-ORB dataset with unknown joint angles, similar to the experimental setup reported in Section 4.2. We trained four networks with K train = 1/2/3/5 and report the results for a varying number of iterations at test time for each network. Results are reported in Table 7.
First, we observe that for each refiner network (each row in the table), the accuracy is significantly improved by using multiple iterations at test time as opposed to running the network for a single iteration (K test = 1) in a single-shot regression fashion. These results demonstrate that the iterative formulation is crucial to the success of the approach.
Second, we observe that running the network for multiple iterations during training significantly improves the results. For example, for K test = 10, the ADD results are improved from 41.25 for K train = 1 to 70.77 for K train = 5. Using multiple training iterations without backpropagating through the renderer augments the distribution of errors between the input state and the ground truth state with actual errors the refiner makes. These results show the importance of training the refiner network to correct both the large errors (between the initial state S 0 and the ground truth state S gt ) as well as smaller errors (between the prediction at iteration k, S k , and S gt ) to simulate what the network is going to see at test-time where the network is run for multiple iterations. In our experiments in the paper, we used K train = 3 as it is a good trade-off between performance and training speed.

H. Applications in robotic set-ups
Similar to related work [28,63], our approach can be applied in real robotic set-ups. For example, the offline hand-eye calibration approach DREAM [28] has been used in [54] for a manipulation task on a real robot, and CRAVES [63] demonstrates visually guided closed-loop control of a low-cost robot without reliable joint angle measurements. Our approach significantly improves over the accuracy of DREAM [63] and CRAVES [28], and therefore X X X X X X X X  Table 7: Benefits of the iterative refinement. We study the influence of the number of training and testing iterations, denoted Ktrain and Ktest, respectively. We report the ADD metric (higher is better) on the Panda ORB dataset with unknown joint angles. The best performing set-up is shown in bold.
we expect to also improve the capabilities of robotic systems similar to [54,63]. Please note that while our paper focuses on the robot state estimation from a single image, it is also suited for real-time and online applications as explained in Section 4.1. In this scenario (also illustrated in the video on the project webpage [1]), our predictions could be temporally smoothed to reduce the jitter in the predictions by applying a simple temporal low-pass filter similar to [54].

I. Qualitative examples
Random examples. Here we provide more qualitative examples on the datasets where we have shown the quantitative evaluation. All the presented results consider the most challenging scenario where the joint angles are unknown and are predicted together with the robot's 6D pose. For each dataset, we have randomly sampled 9 images without any further manual selection and show the input RGB image and the output state predicted by our method. Results are presented for the CRAVES-lab (Figure 8), CRAVES-youtube (Figure 9), Panda ORB ( Figure 10), Kuka Photo ( Figure 11) and Baxter DR (Figure 12) datasets.

J. Failure modes
There are four main failure modes and limitations of our approach in the most challenging set-up with unknown joint angles, illustrated in Figure 13. First, while our method is tolerant to some amount of self-occlusion, it can fail in situations where multiple parts of the robot are occluded by external objects. Second, in some in-the-wild images (where camera intrinsics are also unknown), our iterative alignment can get stuck in a local minima. This could be improved by (i) using a better initialization (e.g. by using a separate external coarse estimation method) or by (ii) trying multiple initializations and selecting the best result. The third failure mode is related to the symmetry of individual robot parts or of entire robot configurations that are not taken into account in our method. Finally, robots with many degrees of freedom such as the 15 DoF Baxter remain challenging (please see the quantitative evaluation in Section 4.2 in the main paper), although our qualitative results often show reasonable alignment, as illustrated in Figure 12.     and the predicted state of the robot within the 3D scene (right). We illustrate the predicted state (right) by overlaying the articulated CAD model of the robot in the predicted state over the input image. Figure 13: Main failure modes. We illustrate the four main failure modes of our approach. In (1), the severe occlusions (circled in red) of the base of the robot and of one of the parts in the middle of the kinematic chain lead to an incorrect prediction. In (2), the state of the robot is incorrectly estimated because our iterative procedure gets stuck in a local minimum. In (3), the gripper of the robot (circled in red) is a symmetric part, which leads to an incorrect estimate of the joint angle between the gripper and the rest of the robot. In (4), we illustrate an example of incorrect alignment of parts (circled in red) for the complex 15 DoF Baxter robot.