Pose2Drone: A Skeleton-Pose-based Framework for Human-Drone Interaction

05/27/2021 ∙ by Zdravko Marinov, et al. ∙ KIT 0

Drones have become a common tool, which is utilized in many tasks such as aerial photography, surveillance, and delivery. However, operating a drone requires more and more interaction with the user. A natural and safe method for Human-Drone Interaction (HDI) is using gestures. In this paper, we introduce an HDI framework building upon skeleton-based pose estimation. Our framework provides the functionality to control the movement of the drone with simple arm gestures and to follow the user while keeping a safe distance. We also propose a monocular distance estimation method, which is entirely based on image features and does not require any additional depth sensors. To perform comprehensive experiments and quantitative analysis, we create a customized testing dataset. The experiments indicate that our HDI framework can achieve an average of 93.5% accuracy in the recognition of 11 common gestures. The code is available at: https://github.com/Zrrr1997/Pose2Drone



There are no comments yet.


page 1

page 2

page 3

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

As drones, or Unmanned Ariel Vehicles (UAVs), have become increasingly more accessible, the interest in integrating them into different aspects of our lives is continuously growing. As such, drones are not only used for photography and filming [13, 14], or shipping and delivery[11], but they are also utilized for navigating visually impaired persons[1]. For this task, assisting drones are often operated via a remote control[3]. This hinders the dynamic interaction as one requires either excessive human input[19], outlaying a path via markers[2] or an integrated GPS-module[5]. This issue becomes especially apparent when one wants to translate interactive drones into unseen environments. To tackle this problem, one needs a method that is robust to domain changes such as switching between indoor and outdoor environments and requires a minimally complex user input. Thus, we propose a framework, which is based on a skeleton pose prediction of the human pose. This enables the drone to recognize gestures and react to them in real-time while being robust to domain changes. The drone’s movement can be controlled by a predefined set of arm gestures, making it possible to maneuver the UAV intuitively by any user without the need for any prior technical knowledge. We also provide a face-following mode, in which the drone follows the user’s face and maintains a safe distance.

Fig. 1: Examples of our framework’s functionality: (a) A frontal gesture command for an upward movement, (b) A gesture which commands the drone to come in front of the user, (c) Face tracking keeps the user’s face in the center of the frame, and (d) The drone maintains a distance to the user.


In this paper, we propose the first, to our knowledge, existing skeleton-pose-based drone control framework. After a specific user registers as main applicant for the drone via facial recognition features, the user’s control is characterized by two different modes for the drone’s movement. The first mode, Face Following (FF), allows the drone to track the user’s face while keeping a certain distance from him as seen in Fig.

1(c) and Fig. 1(d). The second mode, Gesture Control (GC), allows commanding the drone with arm gestures, in which the drone performs a specific action according to a predefined gesture-action pair. The functionality of our framework can be seen in Fig. 1.

Fig. 2: Our framework’s pipeline. Each green box represents a ROS Node. The arrows show the ROS Topics and their corresponding subscribers and publishers. The outputs, indicated in red, are the data which is published in the ROS Topics. All modules are run on a Linux machine.

Ii Related Work

A common method to interact with drones is e.g. via a remote control[3]. This way, drone operators can maneuver drones with precision and create highly synchronized drone swarms[19]. However, controlling drones in this manner demands professional prior training, which complicates the interaction for regular users and this type of HDI often requires setting a fixed route or executing a series of predefined movements, which limits the natural interaction with the drone[19]. In contrast, while our HDI framework can integrate remote-control via keyboard inputs, it enables any face-registered user to safely and intuitively manipulate the drone, utilizing the the FF and GC modes.

Gestures are the most commonly used alternative modality for HDI[19] and are well-perceived[5]. Some previous approaches use depth cameras in addition to an RGB stream to determine the visibility, position, and shape of the arms and hands and recognize a gesture[6, 15]. Other methods have been proposed based only on an onboard RGB camera[17, 12]. Such methods extract visual features from the image to recognize the gesture without requiring additional depth sensors. Cauchard et al.[6] use hand gestures for navigating a projected user interface menu and selecting actions for the drone to perform. Another usage of hand gestures is to issue movement commands directly with the gesture, e.g., by pointing at a direction[12]. However, traditional image-based gesture recognition approaches suffer from sensitivity to occlusion and illumination variation[7]. Thus, we propose a skeleton-pose-based framework for gesture recognition, which is shown to be significantly robust to both issues.

Iii Proposed Framework

Our framework is displayed in Fig. 2. Its pipeline consists of five modules, which are implemented as Robotic Operating System (ROS)[16] Nodes and communicate with each other via ROS Topics. ROS Nodes can subscribe and publish to a topic, i.e., they can receive input data and send output data via the topic. This is indicated by the gray arrows in Fig. 2.

Iii-a RGB Stream Module

The RGB stream module serves to provide images, captured by the drone’s camera, to the pose module. The frames are retrieved via a UDP connection with the drone and are forwarded by maintaining a predefined frame rate. In addition, this is the only point, where frames are being transferred via ROS, which reduces the transmission overhead in the rest of the framework.

Iii-B Pose Module

The pose module receives images from the RGB stream modules, which are used to estimate the joint locations of the user in the image with OpenPose[4]. For our framework, we only consider a subset of all joints. These are labeled with their indices in Fig. 3 in the ”Cheese” gesture. These locations are used as features for the view estimation and face recognition submodules as indicated by the gray arrows inside the pose module in Fig. 2. We further define the distance between two joint locations and as their 2D Euclidean distance:


Iii-B1 View Estimation

The view estimation submodule uses the joint locations

to classify the orientation of the person into the view classes

. It is achieved by a purely geometrical approach by estimating the angle of the shoulder axis with the image plane. Since OpenPose’s joint locations are 2D, the real 3D angle with the image plane can only be approximated. We accomplish this by comparing the -weighted nose-to-neck distance with the shoulder width , where

is a hyperparameter. We also differentiate between the frontal and back view with the help of the relative positions of the ears to each other.

if (2a)
if (2b)
if (2c)
else (2d)

The motive behind this method is that the nose-to-neck distance is significantly independent of the person’s orientation, whereas the shoulder width becomes smaller when the person is standing sideways. We also only compute the ratio between the two distances, which makes this approach viable at any distance from the camera.

If (2a) does not hold, we check whether the left ear is on the left side with respect to right ear and classify the view as . Similarly, if it is on the right side, the view is classified as . However, if all (2a), (2b), and (2c) do not hold, the view class is . We introduced this class so that the definitions of the other view classes are more strict and more consistent.

Iii-B2 Face Recognition

The face recognition ensures that only one concrete person’s gestures influence the drone and only his face is followed. Other people’s gestures and faces in the frame are ignored. There is no conventional face detection in this module. Instead, we use the bounding box of the convex hull of the head joint locations (i.e., ears, eyes, nose, and neck). To capture the whole head, the bounding box is extended by a fixed margin across the width and height. This method makes it possible to infer the user’s head bounding box from all views, even where there is no apparent face on the frame, e.g., from the back view.

Afterward, the image crop from the bounding box is forwarded to the face recognition submodule, where we use a standard face recognition framework (see Subsection IV-A). This method requires a predefined template database images of faces and searches for the best match to the input bounding box. If the user’s face is not matched in the current frame, the closest head bounding box to the last matched face is taken and tracked.

Iii-C Gesture Module

The goal of the gesture module is to recognize arm gestures from a user, which could be either frontal or side gestures. The module receives the joint locations of the user from the OpenPose module as well as the estimated view class . The gesture module determines whether a gesture is present and if the same gesture is recognized within frames, then a corresponding gesture control command is sent to the movement control, where is a hyperparameter.

The idea of the gesture recognition is, similarly to the view estimation, based on a purely geometrical approach and requires that both of the user’s arms are visible. According to the elbow angle , we classify for each arm the angle state {Straight, Perpendicular, None}. In practice, it is not feasible to require the elbow angle to be exactly at ° for a perpendicular state or at ° for a straight state. Therefore, we allow a certain interval of degrees, in which the state is recognized as perpendicular or as straight.

if (3a)
if (3b)
else (3c)
Fig. 3: Examples for all the implemented gestures in our framework. The joint labels can be seen in the ”Cheese” gesture.

Additionally, we also distinguish the position states {Over, Under, Middle}, which refer to the hand’s position with respect to the shoulder. This gives us the tuples and for the left and right arm. If and are both not None, the tuples are used to classify a gesture. For example, in Fig. 4 we see for both and are Perpendicular and both and are Over, which constitute the ”Up” gesture. As seen in Fig. 3 not all possible combinations of angle states and position states are implemented, but the gesture set could easily be extended.

The side gestures are special gestures, which require the arm to be perpendicular to the body and the view class to be . We included these two gestures so that the user can issue the ”Circle Around” (see Fig. 1) command, where the drone flies in front of the user, following a quarter-circle trajectory. We distinguish between ”Side Left” and ”Side Right” so the drone correctly flies in front of the user, instead of behind him.

A gesture is only forwarded to the movement control when it has been recognized for at least consecutive frames. If the previously sent gesture is the same gesture, a certain time period must first pass to avoid sending the same gesture too often as illustrated in Fig. 4. A summary of all implemented gestures can be seen in Fig. 3.

Fig. 4: Temporal stability of the recognized gestures

Iii-D Distance Module

The distance module is responsible for estimating the distance to the user. We use the dimensions of the face bounding box as well as their product as input features as their values are distance dependent. We also include the neck-to-waist distance

for the same reason. Lastly, a one-hot-encoding

of the estimated view class is used, where and are combined into one common class. Then

are concatenated into a 7-dimensional input vector for the distance estimation.

The distance estimation is formulated as a classification problem with the target distance classes

, where the indices represent a distance in centimeters. We apply a fully-connected neural network (FCNN) to solve this classification problem as seen in Fig.


. The FCNN contains 4 hidden layers with 1000 hidden units each. A dropout layer is added to avoid overfitting and a residual connection, which proved to decrease the training time. The output is a softmax layer, which models a posterior distribution of the distance classes. The training and evaluation of this model are discussed in Section


To achieve a continuous estimation from the FCNN, for each distance class and its corresponding softmax output , a weight is computed by

if (4a)
else (4b)

where is the largest softmax output. The resulting weight vector w is then normalized to w so that the sum of the weights is equal to 1. Finally, the weighted sum is computed, which is a convex combination of the class labels. After the post-processing, the continuous estimated distance is forwarded to the movement control so that the drone can keep a safe distance from the user.

Fig. 5: Distance Estimation FCNN Architecture

Iii-E Movement Control Module

To ensure the experimental process and provide a variety of control methods, we divide the movement control module into three modes: keyboard, face tracking, and gesture control mode. The distance control is used for the face tracking mode. The keyboard mode is used to switch between modes and to ensure the safe flight of the drone. It can also execute an emergency shut down to avoid collisions. The inputs for the face tracking mode are the distance to user and the center coordinates of the face bounding box . The face tracking mode sends movement commands with speed and direction information to the drone so that the user’s face is kept in the center of the frame and a certain distance is maintained away from the user. When the gesture control mode receives a gestures command, (e.g., ”Up”), from the gesture module, it enables the drone to execute the demanded action.

To control the drone, PID controllers [9] have to be created for each of these movements. The PID controller is a control loop feedback mechanism that computes the deviation between a given value (measured process value) and the desired value (setpoint) and corrects it based on the proportional, derivative, and integral terms. Equation (5) illustrates this.


where is the difference between and . represents the setpoint, the measured process value, and the control signal. Each PID controller has to be tuned independently to find the correct parameters that will lead to a smooth movement. With Trial and Error method[10], we start with setting both and to zero and increase until the system reaches an oscillating behaviour. Afterwards, we adjust to stop the oscillation and finally adjust for a faster response.

Additionally, in order to complete the gesture control, we need to ensure that the drone can automatically fly to the front of the user. We designed the ”Circle Around” control as seen in Fig 1(b), which consists of two actions: fly from the side to the front of the user and rotate 90° to face the user.

Iv Evaluation

Iv-a Implementation Details

Iv-A1 Preliminaries

We used the DJI Tello Drone[18] to implement our framework. The Tello drone is a quadrotor, which has a 5MP 720p RGB frontal camera and a distance sensor on its bottom side to stabilize its flight. The lack of a frontal depth sensor and a Bluetooth interface encouraged us to implement a monocular image-based distance estimation to the user. To control the movement of the drone and receive information about its state, we utilized the Tello SDK[18], which allows connecting to the drone via a WiFi UDP connection. Through this connection, text commands for movement control can be sent as well as queries about the current state of the drone, e.g. the current altitude. We use a Python implementation of DLIB[8]

as CNN-based face recognition. The distance module FCNN is implemented with PyTorch and we use a Tensorflow implementation of OpenPose. We utilize an Nvidia GeForce RTX 2070 8 GB and 16 GB of RAM to run our framework with 8-9 FPS. We set

, and ms for our hyperparameters.

Iv-A2 Datasets and training

To perform the supervised training of the FCNN distance estimator, we create a training dataset consisting of 960 images of each distance class

(4800 samples in total), where a person performs various gestures to simulate a real-use scenario. We train the network for 15 epochs with softmax-cross-entropy. Additionally, to evaluate our modules we created a custom test dataset, which consists of a person performing all the gestures while rotating to simulate different views and altering the lighting. In all datasets, the gestures are performed with slight modifications concerning the angle and position of the arms. 600 frames are recorded for each distance class, which leads to 3000 test samples in total.

Iv-B Experiments

Iv-B1 Distance evaluation

The distance estimation is evaluated via the Mean Absolute Error (MAE) and Mean Standard Deviation (MSD) metric in centimeters. The MAE for all the distance classes is estimated at

with an MSD of . The farthest distance classes contribute to a larger MAE, e.g., for , the MAE is as seen in Table I.

[width=0.24]MetricClass Average
MAE (cm) 2.47 15.15 13.27 12.99 30.94 17.75
MSD (cm) 5.22 12.73 15.98 11.82 24.01 19.6
TABLE I: Results of the Distance Estimation Evaluation

In Fig. 6 we can see that the distributions of the width-height product in our training dataset have a distinct shape with slightly overlapping regions for all distance classes. The distinct shapes of the distributions are a motivation for the FCNN classifier, which is able to separate the distance classes in the latent space. We also see why the one-hot-encoding of the view is needed as an input feature. If the view was not included, the distributions in Fig. 6 would have a significant overlap, e.g., in the side and in the front view.

Fig. 6: Distribution of the width-height product in the training dataset.

Iv-B2 Gesture evaluation

As the gesture recognition is entirely based on a geometrical approach, it does not require any training. The only hyperparameter is which is responsible for the temporal stability of the gestures. It can be set higher if a preciser control is required or lower for a smaller latency. We use the evaluation dataset described in Subsection IV-A. In our experiment we consider each frame as stable, i.e., . The accuracy of a gesture is equal to the proportion of its correctly recognized frames from the dataset. The proportion of the recognized gestures to all frames is seen in Table II. The average recognition accuracy of the gestures is 93.5%.

Gesture Accuracy
Type Action Name
Frontal Translational movement Up 98.8%
Down 66.6%
Left 98.6%
Right 97.1%
Forward 97.4%
Backward 94.1%
Rotational movement Clockwise (Cw) 97.4%
Counter-clockwise (Ccw) 97.2%
Take a photo Cheese 96.6%
Side Circle around Side-left 89.2%
Side-right 95.6%
Average accuracy 93.5%
TABLE II: Results from the Gesture Recognition Evaluation

The gesture accuracy depends entirely on the joints estimations from OpenPose and the correctness of the gesture execution from the user. The gestures are designed in a natural way as each gesture represents the demanded movement, i.e., pointing left for the drone to fly left. As many of the gestures have an opposite gesture, they are mapped to mirrored arm positions as in Fig. 3. (e.g., ”Up” and ”Down” gestures). The only gesture, which is not easily recognized is the ”Down” gesture as it is physically difficult to perform.

V Conclusions

The results from the evaluation show that despite the hardware limitation of the DJI Tello drone, it is possible to achieve a robust distance estimation as well as a reliable gesture recognition. This is made possible by leveraging a skeleton-based pose estimation, which we showed provides sufficient features for both tasks. The high average gesture recognition accuracy (93.5%) enables a smooth and natural HDI and the low MAE/MSD for the distance estimation ensures the user’s safety. The framework can control the drone in real-time, enabling a natural and simple interaction. Due to its modularity and extensibility, our framework could be integrated and further developed in various other applications.


  • [1] M. Avila, M. Funk, and N. Henze (2015) Dronenavigator: using drones for navigating visually impaired persons. In Proceedings of the 17th International ACM SIGACCESS Conference on Computers & Accessibility, pp. 327–328. Cited by: §I.
  • [2] J. Besada, I. Campaña, L. Bergesio, A. Bernardos, and G. de Miguel (2020) Drone flight planning for safe urban operations. Personal and Ubiquitous Computing, pp. 1–20. Cited by: §I.
  • [3] F. Callou and G. Foinet (2013-November 26) Method for the intuitive piloting of a drone by means of a remote control. Google Patents. Note: US Patent 8,594,862 Cited by: §I, §II.
  • [4] Z. Cao, G. Hidalgo, T. Simon, S. Wei, and Y. Sheikh (2019) OpenPose: realtime multi-person 2d pose estimation using part affinity fields. IEEE transactions on pattern analysis and machine intelligence 43 (1), pp. 172–186. Cited by: §III-B.
  • [5] J. R. Cauchard, J. L. E, K. Y. Zhai, and J. A. Landay (2015) Drone & me: an exploration into natural human-drone interaction. In Proceedings of the 2015 ACM international joint conference on pervasive and ubiquitous computing, pp. 361–365. Cited by: §I, §II.
  • [6] J. R. Cauchard, A. Tamkin, C. Y. Wang, L. Vink, M. Park, T. Fang, and J. A. Landay (2019) Drone. io: a gestural and visual interface for human-drone interaction. In 2019 14th ACM/IEEE International Conference on Human-Robot Interaction (HRI), pp. 153–162. Cited by: §II.
  • [7] B. K. Chakraborty, D. Sarma, M. K. Bhuyan, and K. F. MacDorman (2018) Review of constraints on vision-based gesture recognition for human–computer interaction.

    IET Computer Vision

    12 (1), pp. 3–15.
    Cited by: §II.
  • [8] A. Geitgey (2020) Ageitgey/face_recognition: the world’s simplest facial recognition api for python and the command line. External Links: Link Cited by: §IV-A1.
  • [9] C. Knospe (2006) PID control. IEEE Control Systems Magazine 26 (1), pp. 30–31. Cited by: §III-E.
  • [10] N. Kuyvenhoven (2002) PID tuning methods an automatic pid tuning study with mathcad. Calvin college ENGR 315. Cited by: §III-E.
  • [11] M. McFarland (2016) Google drones will deliver chipotle burritos at virginia tech. CNN Money, September. Cited by: §I.
  • [12] J. Nagi, A. Giusti, G. A. Di Caro, and L. M. Gambardella (2014) Human control of uavs using face pose estimates and hand gestures. In 2014 9th ACM/IEEE International Conference on Human-Robot Interaction (HRI), pp. 1–2. Cited by: §II.
  • [13] F. Patrona, P. Nousi, I. Mademlis, A. Tefas, and I. Pitas (2020) Visual object detection for autonomous uav cinematography. In

    Proceedings of the Northern Lights Deep Learning Workshop

    Vol. 1, pp. 6–6. Cited by: §I.
  • [14] E. Patsiouras, A. Tefas, and I. Pitas (2020) Few-shot image recognition for uav sports cinematography. In

    Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops

    pp. 238–239. Cited by: §I.
  • [15] A. Sanna, F. Lamberti, G. Paravati, and F. Manuri (2013) A kinect-based natural interface for quadrotor control. Entertainment Computing 4 (3), pp. 179–186. Cited by: §II.
  • [16]

    Stanford Artificial Intelligence Laboratory et al.

    Robotic operating system. External Links: Link Cited by: §III.
  • [17] T. Sun, S. Nie, D. Yeung, and S. Shen (2017) Gesture-based piloting of an aerial robot using monocular vision. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 5913–5920. Cited by: §II.
  • [18] Tello: ryze robotics. External Links: Link Cited by: §IV-A1.
  • [19] D. Tezza and M. Andujar (2019) The state-of-the-art of human–drone interaction: a survey. IEEE Access 7, pp. 167438–167454. Cited by: §I, §II, §II.