Fawkes API  Fawkes Development Version
HumanSkeletonInterface.cpp
1 
2 /***************************************************************************
3  * HumanSkeletonInterface.cpp - Fawkes BlackBoard Interface - HumanSkeletonInterface
4  *
5  * Templated created: Thu Oct 12 10:49:19 2006
6  * Copyright 2007-2011 Tim Niemueller
7  *
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version. A runtime exception applies to
14  * this software (see LICENSE.GPL_WRE file mentioned below for details).
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Library General Public License for more details.
20  *
21  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22  */
23 
24 #include <interfaces/HumanSkeletonInterface.h>
25 
26 #include <core/exceptions/software.h>
27 
28 #include <map>
29 #include <string>
30 #include <cstring>
31 #include <cstdlib>
32 
33 namespace fawkes {
34 
35 /** @class HumanSkeletonInterface <interfaces/HumanSkeletonInterface.h>
36  * HumanSkeletonInterface Fawkes BlackBoard Interface.
37  *
38 
39  * @ingroup FawkesInterfaces
40  */
41 
42 
43 
44 /** Constructor */
45 HumanSkeletonInterface::HumanSkeletonInterface() : Interface()
46 {
47  data_size = sizeof(HumanSkeletonInterface_data_t);
48  data_ptr = malloc(data_size);
49  data = (HumanSkeletonInterface_data_t *)data_ptr;
50  data_ts = (interface_data_ts_t *)data_ptr;
51  memset(data_ptr, 0, data_size);
52  enum_map_State[(int)STATE_INVALID] = "STATE_INVALID";
53  enum_map_State[(int)STATE_DETECTING_POSE] = "STATE_DETECTING_POSE";
54  enum_map_State[(int)STATE_CALIBRATING] = "STATE_CALIBRATING";
55  enum_map_State[(int)STATE_TRACKING] = "STATE_TRACKING";
56  add_fieldinfo(IFT_ENUM, "state", 1, &data->state, "State", &enum_map_State);
57  add_fieldinfo(IFT_UINT32, "user_id", 1, &data->user_id);
58  add_fieldinfo(IFT_INT32, "visibility_history", 1, &data->visibility_history);
59  add_fieldinfo(IFT_STRING, "pose", 32, data->pose);
60  add_fieldinfo(IFT_FLOAT, "com", 3, &data->com);
61  add_fieldinfo(IFT_FLOAT, "pos_head", 3, &data->pos_head);
62  add_fieldinfo(IFT_FLOAT, "pos_head_confidence", 1, &data->pos_head_confidence);
63  add_fieldinfo(IFT_FLOAT, "pos_neck", 3, &data->pos_neck);
64  add_fieldinfo(IFT_FLOAT, "pos_neck_confidence", 1, &data->pos_neck_confidence);
65  add_fieldinfo(IFT_FLOAT, "pos_torso", 3, &data->pos_torso);
66  add_fieldinfo(IFT_FLOAT, "pos_torso_confidence", 1, &data->pos_torso_confidence);
67  add_fieldinfo(IFT_FLOAT, "pos_waist", 3, &data->pos_waist);
68  add_fieldinfo(IFT_FLOAT, "pos_waist_confidence", 1, &data->pos_waist_confidence);
69  add_fieldinfo(IFT_FLOAT, "pos_left_collar", 3, &data->pos_left_collar);
70  add_fieldinfo(IFT_FLOAT, "pos_left_collar_confidence", 1, &data->pos_left_collar_confidence);
71  add_fieldinfo(IFT_FLOAT, "pos_left_shoulder", 3, &data->pos_left_shoulder);
72  add_fieldinfo(IFT_FLOAT, "pos_left_shoulder_confidence", 1, &data->pos_left_shoulder_confidence);
73  add_fieldinfo(IFT_FLOAT, "pos_left_elbow", 3, &data->pos_left_elbow);
74  add_fieldinfo(IFT_FLOAT, "pos_left_elbow_confidence", 1, &data->pos_left_elbow_confidence);
75  add_fieldinfo(IFT_FLOAT, "pos_left_wrist", 3, &data->pos_left_wrist);
76  add_fieldinfo(IFT_FLOAT, "pos_left_wrist_confidence", 1, &data->pos_left_wrist_confidence);
77  add_fieldinfo(IFT_FLOAT, "pos_left_hand", 3, &data->pos_left_hand);
78  add_fieldinfo(IFT_FLOAT, "pos_left_hand_confidence", 1, &data->pos_left_hand_confidence);
79  add_fieldinfo(IFT_FLOAT, "pos_left_fingertip", 3, &data->pos_left_fingertip);
80  add_fieldinfo(IFT_FLOAT, "pos_left_fingertip_confidence", 1, &data->pos_left_fingertip_confidence);
81  add_fieldinfo(IFT_FLOAT, "pos_right_collar", 3, &data->pos_right_collar);
82  add_fieldinfo(IFT_FLOAT, "pos_right_collar_confidence", 1, &data->pos_right_collar_confidence);
83  add_fieldinfo(IFT_FLOAT, "pos_right_shoulder", 3, &data->pos_right_shoulder);
84  add_fieldinfo(IFT_FLOAT, "pos_right_shoulder_confidence", 1, &data->pos_right_shoulder_confidence);
85  add_fieldinfo(IFT_FLOAT, "pos_right_elbow", 3, &data->pos_right_elbow);
86  add_fieldinfo(IFT_FLOAT, "pos_right_elbow_confidence", 1, &data->pos_right_elbow_confidence);
87  add_fieldinfo(IFT_FLOAT, "pos_right_wrist", 3, &data->pos_right_wrist);
88  add_fieldinfo(IFT_FLOAT, "pos_right_wrist_confidence", 1, &data->pos_right_wrist_confidence);
89  add_fieldinfo(IFT_FLOAT, "pos_right_hand", 3, &data->pos_right_hand);
90  add_fieldinfo(IFT_FLOAT, "pos_right_hand_confidence", 1, &data->pos_right_hand_confidence);
91  add_fieldinfo(IFT_FLOAT, "pos_right_fingertip", 3, &data->pos_right_fingertip);
92  add_fieldinfo(IFT_FLOAT, "pos_right_fingertip_confidence", 1, &data->pos_right_fingertip_confidence);
93  add_fieldinfo(IFT_FLOAT, "pos_left_hip", 3, &data->pos_left_hip);
94  add_fieldinfo(IFT_FLOAT, "pos_left_hip_confidence", 1, &data->pos_left_hip_confidence);
95  add_fieldinfo(IFT_FLOAT, "pos_left_knee", 3, &data->pos_left_knee);
96  add_fieldinfo(IFT_FLOAT, "pos_left_knee_confidence", 1, &data->pos_left_knee_confidence);
97  add_fieldinfo(IFT_FLOAT, "pos_left_ankle", 3, &data->pos_left_ankle);
98  add_fieldinfo(IFT_FLOAT, "pos_left_ankle_confidence", 1, &data->pos_left_ankle_confidence);
99  add_fieldinfo(IFT_FLOAT, "pos_left_foot", 3, &data->pos_left_foot);
100  add_fieldinfo(IFT_FLOAT, "pos_left_foot_confidence", 1, &data->pos_left_foot_confidence);
101  add_fieldinfo(IFT_FLOAT, "pos_right_hip", 3, &data->pos_right_hip);
102  add_fieldinfo(IFT_FLOAT, "pos_right_hip_confidence", 1, &data->pos_right_hip_confidence);
103  add_fieldinfo(IFT_FLOAT, "pos_right_knee", 3, &data->pos_right_knee);
104  add_fieldinfo(IFT_FLOAT, "pos_right_knee_confidence", 1, &data->pos_right_knee_confidence);
105  add_fieldinfo(IFT_FLOAT, "pos_right_ankle", 3, &data->pos_right_ankle);
106  add_fieldinfo(IFT_FLOAT, "pos_right_ankle_confidence", 1, &data->pos_right_ankle_confidence);
107  add_fieldinfo(IFT_FLOAT, "pos_right_foot", 3, &data->pos_right_foot);
108  add_fieldinfo(IFT_FLOAT, "pos_right_foot_confidence", 1, &data->pos_right_foot_confidence);
109  add_fieldinfo(IFT_FLOAT, "ori_head", 9, &data->ori_head);
110  add_fieldinfo(IFT_FLOAT, "ori_head_confidence", 1, &data->ori_head_confidence);
111  add_fieldinfo(IFT_FLOAT, "ori_neck", 9, &data->ori_neck);
112  add_fieldinfo(IFT_FLOAT, "ori_neck_confidence", 1, &data->ori_neck_confidence);
113  add_fieldinfo(IFT_FLOAT, "ori_torso", 9, &data->ori_torso);
114  add_fieldinfo(IFT_FLOAT, "ori_torso_confidence", 1, &data->ori_torso_confidence);
115  add_fieldinfo(IFT_FLOAT, "ori_waist", 9, &data->ori_waist);
116  add_fieldinfo(IFT_FLOAT, "ori_waist_confidence", 1, &data->ori_waist_confidence);
117  add_fieldinfo(IFT_FLOAT, "ori_left_collar", 9, &data->ori_left_collar);
118  add_fieldinfo(IFT_FLOAT, "ori_left_collar_confidence", 1, &data->ori_left_collar_confidence);
119  add_fieldinfo(IFT_FLOAT, "ori_left_shoulder", 9, &data->ori_left_shoulder);
120  add_fieldinfo(IFT_FLOAT, "ori_left_shoulder_confidence", 1, &data->ori_left_shoulder_confidence);
121  add_fieldinfo(IFT_FLOAT, "ori_left_elbow", 9, &data->ori_left_elbow);
122  add_fieldinfo(IFT_FLOAT, "ori_left_elbow_confidence", 1, &data->ori_left_elbow_confidence);
123  add_fieldinfo(IFT_FLOAT, "ori_left_wrist", 9, &data->ori_left_wrist);
124  add_fieldinfo(IFT_FLOAT, "ori_left_wrist_confidence", 1, &data->ori_left_wrist_confidence);
125  add_fieldinfo(IFT_FLOAT, "ori_left_hand", 9, &data->ori_left_hand);
126  add_fieldinfo(IFT_FLOAT, "ori_left_hand_confidence", 1, &data->ori_left_hand_confidence);
127  add_fieldinfo(IFT_FLOAT, "ori_left_fingertip", 9, &data->ori_left_fingertip);
128  add_fieldinfo(IFT_FLOAT, "ori_left_fingertip_confidence", 1, &data->ori_left_fingertip_confidence);
129  add_fieldinfo(IFT_FLOAT, "ori_right_collar", 9, &data->ori_right_collar);
130  add_fieldinfo(IFT_FLOAT, "ori_right_collar_confidence", 1, &data->ori_right_collar_confidence);
131  add_fieldinfo(IFT_FLOAT, "ori_right_shoulder", 9, &data->ori_right_shoulder);
132  add_fieldinfo(IFT_FLOAT, "ori_right_shoulder_confidence", 1, &data->ori_right_shoulder_confidence);
133  add_fieldinfo(IFT_FLOAT, "ori_right_elbow", 9, &data->ori_right_elbow);
134  add_fieldinfo(IFT_FLOAT, "ori_right_elbow_confidence", 1, &data->ori_right_elbow_confidence);
135  add_fieldinfo(IFT_FLOAT, "ori_right_wrist", 9, &data->ori_right_wrist);
136  add_fieldinfo(IFT_FLOAT, "ori_right_wrist_confidence", 1, &data->ori_right_wrist_confidence);
137  add_fieldinfo(IFT_FLOAT, "ori_right_hand", 9, &data->ori_right_hand);
138  add_fieldinfo(IFT_FLOAT, "ori_right_hand_confidence", 1, &data->ori_right_hand_confidence);
139  add_fieldinfo(IFT_FLOAT, "ori_right_fingertip", 9, &data->ori_right_fingertip);
140  add_fieldinfo(IFT_FLOAT, "ori_right_fingertip_confidence", 1, &data->ori_right_fingertip_confidence);
141  add_fieldinfo(IFT_FLOAT, "ori_left_hip", 9, &data->ori_left_hip);
142  add_fieldinfo(IFT_FLOAT, "ori_left_hip_confidence", 1, &data->ori_left_hip_confidence);
143  add_fieldinfo(IFT_FLOAT, "ori_left_knee", 9, &data->ori_left_knee);
144  add_fieldinfo(IFT_FLOAT, "ori_left_knee_confidence", 1, &data->ori_left_knee_confidence);
145  add_fieldinfo(IFT_FLOAT, "ori_left_ankle", 9, &data->ori_left_ankle);
146  add_fieldinfo(IFT_FLOAT, "ori_left_ankle_confidence", 1, &data->ori_left_ankle_confidence);
147  add_fieldinfo(IFT_FLOAT, "ori_left_foot", 9, &data->ori_left_foot);
148  add_fieldinfo(IFT_FLOAT, "ori_left_foot_confidence", 1, &data->ori_left_foot_confidence);
149  add_fieldinfo(IFT_FLOAT, "ori_right_hip", 9, &data->ori_right_hip);
150  add_fieldinfo(IFT_FLOAT, "ori_right_hip_confidence", 1, &data->ori_right_hip_confidence);
151  add_fieldinfo(IFT_FLOAT, "ori_right_knee", 9, &data->ori_right_knee);
152  add_fieldinfo(IFT_FLOAT, "ori_right_knee_confidence", 1, &data->ori_right_knee_confidence);
153  add_fieldinfo(IFT_FLOAT, "ori_right_ankle", 9, &data->ori_right_ankle);
154  add_fieldinfo(IFT_FLOAT, "ori_right_ankle_confidence", 1, &data->ori_right_ankle_confidence);
155  add_fieldinfo(IFT_FLOAT, "ori_right_foot", 9, &data->ori_right_foot);
156  add_fieldinfo(IFT_FLOAT, "ori_right_foot_confidence", 1, &data->ori_right_foot_confidence);
157  unsigned char tmp_hash[] = {0x5f, 0x47, 0x2f, 0xb3, 0x8b, 0xf1, 0xe1, 0xa, 0xb9, 0x42, 0x34, 0xea, 0x83, 0x43, 0x94, 0x37};
158  set_hash(tmp_hash);
159 }
160 
161 /** Destructor */
162 HumanSkeletonInterface::~HumanSkeletonInterface()
163 {
164  free(data_ptr);
165 }
166 /** Convert State constant to string.
167  * @param value value to convert to string
168  * @return constant value as string.
169  */
170 const char *
172 {
173  switch (value) {
174  case STATE_INVALID: return "STATE_INVALID";
175  case STATE_DETECTING_POSE: return "STATE_DETECTING_POSE";
176  case STATE_CALIBRATING: return "STATE_CALIBRATING";
177  case STATE_TRACKING: return "STATE_TRACKING";
178  default: return "UNKNOWN";
179  }
180 }
181 /* Methods */
182 /** Get state value.
183  * Current state.
184  * @return state value
185  */
188 {
189  return (HumanSkeletonInterface::State)data->state;
190 }
191 
192 /** Get maximum length of state value.
193  * @return length of state value, can be length of the array or number of
194  * maximum number of characters for a string
195  */
196 size_t
198 {
199  return 1;
200 }
201 
202 /** Set state value.
203  * Current state.
204  * @param new_state new state value
205  */
206 void
208 {
209  data->state = new_state;
210  data_changed = true;
211 }
212 
213 /** Get user_id value.
214  * Tracking ID of this user.
215  * @return user_id value
216  */
217 uint32_t
219 {
220  return data->user_id;
221 }
222 
223 /** Get maximum length of user_id value.
224  * @return length of user_id value, can be length of the array or number of
225  * maximum number of characters for a string
226  */
227 size_t
229 {
230  return 1;
231 }
232 
233 /** Set user_id value.
234  * Tracking ID of this user.
235  * @param new_user_id new user_id value
236  */
237 void
238 HumanSkeletonInterface::set_user_id(const uint32_t new_user_id)
239 {
240  data->user_id = new_user_id;
241  data_changed = true;
242 }
243 
244 /** Get visibility_history value.
245  *
246  The visibility history indicates the persistence of user sightings.
247  A positive value indicates the number of successful consecutive sightings
248  of the user (center of mass not equal to zero), the absolute of a negative
249  value gives the number of consecutive negative (non-) sightings. The value
250  is zero only if uninitialized.
251 
252  * @return visibility_history value
253  */
254 int32_t
256 {
257  return data->visibility_history;
258 }
259 
260 /** Get maximum length of visibility_history value.
261  * @return length of visibility_history value, can be length of the array or number of
262  * maximum number of characters for a string
263  */
264 size_t
266 {
267  return 1;
268 }
269 
270 /** Set visibility_history value.
271  *
272  The visibility history indicates the persistence of user sightings.
273  A positive value indicates the number of successful consecutive sightings
274  of the user (center of mass not equal to zero), the absolute of a negative
275  value gives the number of consecutive negative (non-) sightings. The value
276  is zero only if uninitialized.
277 
278  * @param new_visibility_history new visibility_history value
279  */
280 void
281 HumanSkeletonInterface::set_visibility_history(const int32_t new_visibility_history)
282 {
283  data->visibility_history = new_visibility_history;
284  data_changed = true;
285 }
286 
287 /** Get pose value.
288  * Detected user pose.
289  * @return pose value
290  */
291 char *
293 {
294  return data->pose;
295 }
296 
297 /** Get maximum length of pose value.
298  * @return length of pose value, can be length of the array or number of
299  * maximum number of characters for a string
300  */
301 size_t
303 {
304  return 32;
305 }
306 
307 /** Set pose value.
308  * Detected user pose.
309  * @param new_pose new pose value
310  */
311 void
312 HumanSkeletonInterface::set_pose(const char * new_pose)
313 {
314  strncpy(data->pose, new_pose, sizeof(data->pose)-1);
315  data->pose[sizeof(data->pose)-1] = 0;
316  data_changed = true;
317 }
318 
319 /** Get com value.
320  * Center of mass.
321  * @return com value
322  */
323 float *
325 {
326  return data->com;
327 }
328 
329 /** Get com value at given index.
330  * Center of mass.
331  * @param index index of value
332  * @return com value
333  * @exception Exception thrown if index is out of bounds
334  */
335 float
336 HumanSkeletonInterface::com(unsigned int index) const
337 {
338  if (index > 2) {
339  throw Exception("Index value %u out of bounds (0..2)", index);
340  }
341  return data->com[index];
342 }
343 
344 /** Get maximum length of com value.
345  * @return length of com value, can be length of the array or number of
346  * maximum number of characters for a string
347  */
348 size_t
350 {
351  return 3;
352 }
353 
354 /** Set com value.
355  * Center of mass.
356  * @param new_com new com value
357  */
358 void
359 HumanSkeletonInterface::set_com(const float * new_com)
360 {
361  memcpy(data->com, new_com, sizeof(float) * 3);
362  data_changed = true;
363 }
364 
365 /** Set com value at given index.
366  * Center of mass.
367  * @param new_com new com value
368  * @param index index for of the value
369  */
370 void
371 HumanSkeletonInterface::set_com(unsigned int index, const float new_com)
372 {
373  if (index > 2) {
374  throw Exception("Index value %u out of bounds (0..2)", index);
375  }
376  data->com[index] = new_com;
377  data_changed = true;
378 }
379 /** Get pos_head value.
380  * Head position vector.
381  * @return pos_head value
382  */
383 float *
385 {
386  return data->pos_head;
387 }
388 
389 /** Get pos_head value at given index.
390  * Head position vector.
391  * @param index index of value
392  * @return pos_head value
393  * @exception Exception thrown if index is out of bounds
394  */
395 float
396 HumanSkeletonInterface::pos_head(unsigned int index) const
397 {
398  if (index > 2) {
399  throw Exception("Index value %u out of bounds (0..2)", index);
400  }
401  return data->pos_head[index];
402 }
403 
404 /** Get maximum length of pos_head value.
405  * @return length of pos_head value, can be length of the array or number of
406  * maximum number of characters for a string
407  */
408 size_t
410 {
411  return 3;
412 }
413 
414 /** Set pos_head value.
415  * Head position vector.
416  * @param new_pos_head new pos_head value
417  */
418 void
419 HumanSkeletonInterface::set_pos_head(const float * new_pos_head)
420 {
421  memcpy(data->pos_head, new_pos_head, sizeof(float) * 3);
422  data_changed = true;
423 }
424 
425 /** Set pos_head value at given index.
426  * Head position vector.
427  * @param new_pos_head new pos_head value
428  * @param index index for of the value
429  */
430 void
431 HumanSkeletonInterface::set_pos_head(unsigned int index, const float new_pos_head)
432 {
433  if (index > 2) {
434  throw Exception("Index value %u out of bounds (0..2)", index);
435  }
436  data->pos_head[index] = new_pos_head;
437  data_changed = true;
438 }
439 /** Get pos_head_confidence value.
440  *
441  Head position confidence.
442  * @return pos_head_confidence value
443  */
444 float
446 {
447  return data->pos_head_confidence;
448 }
449 
450 /** Get maximum length of pos_head_confidence value.
451  * @return length of pos_head_confidence value, can be length of the array or number of
452  * maximum number of characters for a string
453  */
454 size_t
456 {
457  return 1;
458 }
459 
460 /** Set pos_head_confidence value.
461  *
462  Head position confidence.
463  * @param new_pos_head_confidence new pos_head_confidence value
464  */
465 void
466 HumanSkeletonInterface::set_pos_head_confidence(const float new_pos_head_confidence)
467 {
468  data->pos_head_confidence = new_pos_head_confidence;
469  data_changed = true;
470 }
471 
472 /** Get pos_neck value.
473  * Neck position vector.
474  * @return pos_neck value
475  */
476 float *
478 {
479  return data->pos_neck;
480 }
481 
482 /** Get pos_neck value at given index.
483  * Neck position vector.
484  * @param index index of value
485  * @return pos_neck value
486  * @exception Exception thrown if index is out of bounds
487  */
488 float
489 HumanSkeletonInterface::pos_neck(unsigned int index) const
490 {
491  if (index > 2) {
492  throw Exception("Index value %u out of bounds (0..2)", index);
493  }
494  return data->pos_neck[index];
495 }
496 
497 /** Get maximum length of pos_neck value.
498  * @return length of pos_neck value, can be length of the array or number of
499  * maximum number of characters for a string
500  */
501 size_t
503 {
504  return 3;
505 }
506 
507 /** Set pos_neck value.
508  * Neck position vector.
509  * @param new_pos_neck new pos_neck value
510  */
511 void
512 HumanSkeletonInterface::set_pos_neck(const float * new_pos_neck)
513 {
514  memcpy(data->pos_neck, new_pos_neck, sizeof(float) * 3);
515  data_changed = true;
516 }
517 
518 /** Set pos_neck value at given index.
519  * Neck position vector.
520  * @param new_pos_neck new pos_neck value
521  * @param index index for of the value
522  */
523 void
524 HumanSkeletonInterface::set_pos_neck(unsigned int index, const float new_pos_neck)
525 {
526  if (index > 2) {
527  throw Exception("Index value %u out of bounds (0..2)", index);
528  }
529  data->pos_neck[index] = new_pos_neck;
530  data_changed = true;
531 }
532 /** Get pos_neck_confidence value.
533  *
534  Neck position confidence.
535  * @return pos_neck_confidence value
536  */
537 float
539 {
540  return data->pos_neck_confidence;
541 }
542 
543 /** Get maximum length of pos_neck_confidence value.
544  * @return length of pos_neck_confidence value, can be length of the array or number of
545  * maximum number of characters for a string
546  */
547 size_t
549 {
550  return 1;
551 }
552 
553 /** Set pos_neck_confidence value.
554  *
555  Neck position confidence.
556  * @param new_pos_neck_confidence new pos_neck_confidence value
557  */
558 void
559 HumanSkeletonInterface::set_pos_neck_confidence(const float new_pos_neck_confidence)
560 {
561  data->pos_neck_confidence = new_pos_neck_confidence;
562  data_changed = true;
563 }
564 
565 /** Get pos_torso value.
566  * Torso position vector.
567  * @return pos_torso value
568  */
569 float *
571 {
572  return data->pos_torso;
573 }
574 
575 /** Get pos_torso value at given index.
576  * Torso position vector.
577  * @param index index of value
578  * @return pos_torso value
579  * @exception Exception thrown if index is out of bounds
580  */
581 float
582 HumanSkeletonInterface::pos_torso(unsigned int index) const
583 {
584  if (index > 2) {
585  throw Exception("Index value %u out of bounds (0..2)", index);
586  }
587  return data->pos_torso[index];
588 }
589 
590 /** Get maximum length of pos_torso value.
591  * @return length of pos_torso value, can be length of the array or number of
592  * maximum number of characters for a string
593  */
594 size_t
596 {
597  return 3;
598 }
599 
600 /** Set pos_torso value.
601  * Torso position vector.
602  * @param new_pos_torso new pos_torso value
603  */
604 void
605 HumanSkeletonInterface::set_pos_torso(const float * new_pos_torso)
606 {
607  memcpy(data->pos_torso, new_pos_torso, sizeof(float) * 3);
608  data_changed = true;
609 }
610 
611 /** Set pos_torso value at given index.
612  * Torso position vector.
613  * @param new_pos_torso new pos_torso value
614  * @param index index for of the value
615  */
616 void
617 HumanSkeletonInterface::set_pos_torso(unsigned int index, const float new_pos_torso)
618 {
619  if (index > 2) {
620  throw Exception("Index value %u out of bounds (0..2)", index);
621  }
622  data->pos_torso[index] = new_pos_torso;
623  data_changed = true;
624 }
625 /** Get pos_torso_confidence value.
626  *
627  Torso position confidence.
628  * @return pos_torso_confidence value
629  */
630 float
632 {
633  return data->pos_torso_confidence;
634 }
635 
636 /** Get maximum length of pos_torso_confidence value.
637  * @return length of pos_torso_confidence value, can be length of the array or number of
638  * maximum number of characters for a string
639  */
640 size_t
642 {
643  return 1;
644 }
645 
646 /** Set pos_torso_confidence value.
647  *
648  Torso position confidence.
649  * @param new_pos_torso_confidence new pos_torso_confidence value
650  */
651 void
652 HumanSkeletonInterface::set_pos_torso_confidence(const float new_pos_torso_confidence)
653 {
654  data->pos_torso_confidence = new_pos_torso_confidence;
655  data_changed = true;
656 }
657 
658 /** Get pos_waist value.
659  * Waist position vector.
660  * @return pos_waist value
661  */
662 float *
664 {
665  return data->pos_waist;
666 }
667 
668 /** Get pos_waist value at given index.
669  * Waist position vector.
670  * @param index index of value
671  * @return pos_waist value
672  * @exception Exception thrown if index is out of bounds
673  */
674 float
675 HumanSkeletonInterface::pos_waist(unsigned int index) const
676 {
677  if (index > 2) {
678  throw Exception("Index value %u out of bounds (0..2)", index);
679  }
680  return data->pos_waist[index];
681 }
682 
683 /** Get maximum length of pos_waist value.
684  * @return length of pos_waist value, can be length of the array or number of
685  * maximum number of characters for a string
686  */
687 size_t
689 {
690  return 3;
691 }
692 
693 /** Set pos_waist value.
694  * Waist position vector.
695  * @param new_pos_waist new pos_waist value
696  */
697 void
698 HumanSkeletonInterface::set_pos_waist(const float * new_pos_waist)
699 {
700  memcpy(data->pos_waist, new_pos_waist, sizeof(float) * 3);
701  data_changed = true;
702 }
703 
704 /** Set pos_waist value at given index.
705  * Waist position vector.
706  * @param new_pos_waist new pos_waist value
707  * @param index index for of the value
708  */
709 void
710 HumanSkeletonInterface::set_pos_waist(unsigned int index, const float new_pos_waist)
711 {
712  if (index > 2) {
713  throw Exception("Index value %u out of bounds (0..2)", index);
714  }
715  data->pos_waist[index] = new_pos_waist;
716  data_changed = true;
717 }
718 /** Get pos_waist_confidence value.
719  *
720  Waist position confidence.
721  * @return pos_waist_confidence value
722  */
723 float
725 {
726  return data->pos_waist_confidence;
727 }
728 
729 /** Get maximum length of pos_waist_confidence value.
730  * @return length of pos_waist_confidence value, can be length of the array or number of
731  * maximum number of characters for a string
732  */
733 size_t
735 {
736  return 1;
737 }
738 
739 /** Set pos_waist_confidence value.
740  *
741  Waist position confidence.
742  * @param new_pos_waist_confidence new pos_waist_confidence value
743  */
744 void
745 HumanSkeletonInterface::set_pos_waist_confidence(const float new_pos_waist_confidence)
746 {
747  data->pos_waist_confidence = new_pos_waist_confidence;
748  data_changed = true;
749 }
750 
751 /** Get pos_left_collar value.
752  *
753  Left position vector.
754  * @return pos_left_collar value
755  */
756 float *
758 {
759  return data->pos_left_collar;
760 }
761 
762 /** Get pos_left_collar value at given index.
763  *
764  Left position vector.
765  * @param index index of value
766  * @return pos_left_collar value
767  * @exception Exception thrown if index is out of bounds
768  */
769 float
770 HumanSkeletonInterface::pos_left_collar(unsigned int index) const
771 {
772  if (index > 2) {
773  throw Exception("Index value %u out of bounds (0..2)", index);
774  }
775  return data->pos_left_collar[index];
776 }
777 
778 /** Get maximum length of pos_left_collar value.
779  * @return length of pos_left_collar value, can be length of the array or number of
780  * maximum number of characters for a string
781  */
782 size_t
784 {
785  return 3;
786 }
787 
788 /** Set pos_left_collar value.
789  *
790  Left position vector.
791  * @param new_pos_left_collar new pos_left_collar value
792  */
793 void
794 HumanSkeletonInterface::set_pos_left_collar(const float * new_pos_left_collar)
795 {
796  memcpy(data->pos_left_collar, new_pos_left_collar, sizeof(float) * 3);
797  data_changed = true;
798 }
799 
800 /** Set pos_left_collar value at given index.
801  *
802  Left position vector.
803  * @param new_pos_left_collar new pos_left_collar value
804  * @param index index for of the value
805  */
806 void
807 HumanSkeletonInterface::set_pos_left_collar(unsigned int index, const float new_pos_left_collar)
808 {
809  if (index > 2) {
810  throw Exception("Index value %u out of bounds (0..2)", index);
811  }
812  data->pos_left_collar[index] = new_pos_left_collar;
813  data_changed = true;
814 }
815 /** Get pos_left_collar_confidence value.
816  *
817  Left position confidence.
818  * @return pos_left_collar_confidence value
819  */
820 float
822 {
823  return data->pos_left_collar_confidence;
824 }
825 
826 /** Get maximum length of pos_left_collar_confidence value.
827  * @return length of pos_left_collar_confidence value, can be length of the array or number of
828  * maximum number of characters for a string
829  */
830 size_t
832 {
833  return 1;
834 }
835 
836 /** Set pos_left_collar_confidence value.
837  *
838  Left position confidence.
839  * @param new_pos_left_collar_confidence new pos_left_collar_confidence value
840  */
841 void
842 HumanSkeletonInterface::set_pos_left_collar_confidence(const float new_pos_left_collar_confidence)
843 {
844  data->pos_left_collar_confidence = new_pos_left_collar_confidence;
845  data_changed = true;
846 }
847 
848 /** Get pos_left_shoulder value.
849  *
850  Left shoulder position vector.
851  * @return pos_left_shoulder value
852  */
853 float *
855 {
856  return data->pos_left_shoulder;
857 }
858 
859 /** Get pos_left_shoulder value at given index.
860  *
861  Left shoulder position vector.
862  * @param index index of value
863  * @return pos_left_shoulder value
864  * @exception Exception thrown if index is out of bounds
865  */
866 float
867 HumanSkeletonInterface::pos_left_shoulder(unsigned int index) const
868 {
869  if (index > 2) {
870  throw Exception("Index value %u out of bounds (0..2)", index);
871  }
872  return data->pos_left_shoulder[index];
873 }
874 
875 /** Get maximum length of pos_left_shoulder value.
876  * @return length of pos_left_shoulder value, can be length of the array or number of
877  * maximum number of characters for a string
878  */
879 size_t
881 {
882  return 3;
883 }
884 
885 /** Set pos_left_shoulder value.
886  *
887  Left shoulder position vector.
888  * @param new_pos_left_shoulder new pos_left_shoulder value
889  */
890 void
891 HumanSkeletonInterface::set_pos_left_shoulder(const float * new_pos_left_shoulder)
892 {
893  memcpy(data->pos_left_shoulder, new_pos_left_shoulder, sizeof(float) * 3);
894  data_changed = true;
895 }
896 
897 /** Set pos_left_shoulder value at given index.
898  *
899  Left shoulder position vector.
900  * @param new_pos_left_shoulder new pos_left_shoulder value
901  * @param index index for of the value
902  */
903 void
904 HumanSkeletonInterface::set_pos_left_shoulder(unsigned int index, const float new_pos_left_shoulder)
905 {
906  if (index > 2) {
907  throw Exception("Index value %u out of bounds (0..2)", index);
908  }
909  data->pos_left_shoulder[index] = new_pos_left_shoulder;
910  data_changed = true;
911 }
912 /** Get pos_left_shoulder_confidence value.
913  *
914  Left shoulder position confidence.
915  * @return pos_left_shoulder_confidence value
916  */
917 float
919 {
920  return data->pos_left_shoulder_confidence;
921 }
922 
923 /** Get maximum length of pos_left_shoulder_confidence value.
924  * @return length of pos_left_shoulder_confidence value, can be length of the array or number of
925  * maximum number of characters for a string
926  */
927 size_t
929 {
930  return 1;
931 }
932 
933 /** Set pos_left_shoulder_confidence value.
934  *
935  Left shoulder position confidence.
936  * @param new_pos_left_shoulder_confidence new pos_left_shoulder_confidence value
937  */
938 void
939 HumanSkeletonInterface::set_pos_left_shoulder_confidence(const float new_pos_left_shoulder_confidence)
940 {
941  data->pos_left_shoulder_confidence = new_pos_left_shoulder_confidence;
942  data_changed = true;
943 }
944 
945 /** Get pos_left_elbow value.
946  *
947  Left elbow position vector.
948  * @return pos_left_elbow value
949  */
950 float *
952 {
953  return data->pos_left_elbow;
954 }
955 
956 /** Get pos_left_elbow value at given index.
957  *
958  Left elbow position vector.
959  * @param index index of value
960  * @return pos_left_elbow value
961  * @exception Exception thrown if index is out of bounds
962  */
963 float
964 HumanSkeletonInterface::pos_left_elbow(unsigned int index) const
965 {
966  if (index > 2) {
967  throw Exception("Index value %u out of bounds (0..2)", index);
968  }
969  return data->pos_left_elbow[index];
970 }
971 
972 /** Get maximum length of pos_left_elbow value.
973  * @return length of pos_left_elbow value, can be length of the array or number of
974  * maximum number of characters for a string
975  */
976 size_t
978 {
979  return 3;
980 }
981 
982 /** Set pos_left_elbow value.
983  *
984  Left elbow position vector.
985  * @param new_pos_left_elbow new pos_left_elbow value
986  */
987 void
988 HumanSkeletonInterface::set_pos_left_elbow(const float * new_pos_left_elbow)
989 {
990  memcpy(data->pos_left_elbow, new_pos_left_elbow, sizeof(float) * 3);
991  data_changed = true;
992 }
993 
994 /** Set pos_left_elbow value at given index.
995  *
996  Left elbow position vector.
997  * @param new_pos_left_elbow new pos_left_elbow value
998  * @param index index for of the value
999  */
1000 void
1001 HumanSkeletonInterface::set_pos_left_elbow(unsigned int index, const float new_pos_left_elbow)
1002 {
1003  if (index > 2) {
1004  throw Exception("Index value %u out of bounds (0..2)", index);
1005  }
1006  data->pos_left_elbow[index] = new_pos_left_elbow;
1008 }
1009 /** Get pos_left_elbow_confidence value.
1010  *
1011  Left elbow position confidence.
1012  * @return pos_left_elbow_confidence value
1013  */
1014 float
1016 {
1017  return data->pos_left_elbow_confidence;
1018 }
1019 
1020 /** Get maximum length of pos_left_elbow_confidence value.
1021  * @return length of pos_left_elbow_confidence value, can be length of the array or number of
1022  * maximum number of characters for a string
1023  */
1024 size_t
1026 {
1027  return 1;
1028 }
1029 
1030 /** Set pos_left_elbow_confidence value.
1031  *
1032  Left elbow position confidence.
1033  * @param new_pos_left_elbow_confidence new pos_left_elbow_confidence value
1034  */
1035 void
1036 HumanSkeletonInterface::set_pos_left_elbow_confidence(const float new_pos_left_elbow_confidence)
1037 {
1038  data->pos_left_elbow_confidence = new_pos_left_elbow_confidence;
1039  data_changed = true;
1040 }
1041 
1042 /** Get pos_left_wrist value.
1043  *
1044  Left wrist position vector.
1045  * @return pos_left_wrist value
1046  */
1047 float *
1049 {
1050  return data->pos_left_wrist;
1051 }
1052 
1053 /** Get pos_left_wrist value at given index.
1054  *
1055  Left wrist position vector.
1056  * @param index index of value
1057  * @return pos_left_wrist value
1058  * @exception Exception thrown if index is out of bounds
1059  */
1060 float
1061 HumanSkeletonInterface::pos_left_wrist(unsigned int index) const
1062 {
1063  if (index > 2) {
1064  throw Exception("Index value %u out of bounds (0..2)", index);
1065  }
1066  return data->pos_left_wrist[index];
1068 
1069 /** Get maximum length of pos_left_wrist value.
1070  * @return length of pos_left_wrist value, can be length of the array or number of
1071  * maximum number of characters for a string
1072  */
1073 size_t
1075 {
1076  return 3;
1077 }
1078 
1079 /** Set pos_left_wrist value.
1080  *
1081  Left wrist position vector.
1082  * @param new_pos_left_wrist new pos_left_wrist value
1083  */
1084 void
1085 HumanSkeletonInterface::set_pos_left_wrist(const float * new_pos_left_wrist)
1086 {
1087  memcpy(data->pos_left_wrist, new_pos_left_wrist, sizeof(float) * 3);
1088  data_changed = true;
1089 }
1090 
1091 /** Set pos_left_wrist value at given index.
1092  *
1093  Left wrist position vector.
1094  * @param new_pos_left_wrist new pos_left_wrist value
1095  * @param index index for of the value
1096  */
1097 void
1098 HumanSkeletonInterface::set_pos_left_wrist(unsigned int index, const float new_pos_left_wrist)
1099 {
1100  if (index > 2) {
1101  throw Exception("Index value %u out of bounds (0..2)", index);
1102  }
1103  data->pos_left_wrist[index] = new_pos_left_wrist;
1105 }
1106 /** Get pos_left_wrist_confidence value.
1107  *
1108  Left wrist position confidence.
1109  * @return pos_left_wrist_confidence value
1110  */
1111 float
1113 {
1114  return data->pos_left_wrist_confidence;
1115 }
1116 
1117 /** Get maximum length of pos_left_wrist_confidence value.
1118  * @return length of pos_left_wrist_confidence value, can be length of the array or number of
1119  * maximum number of characters for a string
1120  */
1121 size_t
1123 {
1124  return 1;
1125 }
1126 
1127 /** Set pos_left_wrist_confidence value.
1128  *
1129  Left wrist position confidence.
1130  * @param new_pos_left_wrist_confidence new pos_left_wrist_confidence value
1131  */
1132 void
1133 HumanSkeletonInterface::set_pos_left_wrist_confidence(const float new_pos_left_wrist_confidence)
1134 {
1135  data->pos_left_wrist_confidence = new_pos_left_wrist_confidence;
1136  data_changed = true;
1137 }
1138 
1139 /** Get pos_left_hand value.
1140  *
1141  Left hand position vector.
1142  * @return pos_left_hand value
1143  */
1144 float *
1146 {
1147  return data->pos_left_hand;
1148 }
1149 
1150 /** Get pos_left_hand value at given index.
1151  *
1152  Left hand position vector.
1153  * @param index index of value
1154  * @return pos_left_hand value
1155  * @exception Exception thrown if index is out of bounds
1156  */
1157 float
1158 HumanSkeletonInterface::pos_left_hand(unsigned int index) const
1159 {
1160  if (index > 2) {
1161  throw Exception("Index value %u out of bounds (0..2)", index);
1162  }
1163  return data->pos_left_hand[index];
1165 
1166 /** Get maximum length of pos_left_hand value.
1167  * @return length of pos_left_hand value, can be length of the array or number of
1168  * maximum number of characters for a string
1169  */
1170 size_t
1172 {
1173  return 3;
1174 }
1175 
1176 /** Set pos_left_hand value.
1177  *
1178  Left hand position vector.
1179  * @param new_pos_left_hand new pos_left_hand value
1180  */
1181 void
1182 HumanSkeletonInterface::set_pos_left_hand(const float * new_pos_left_hand)
1183 {
1184  memcpy(data->pos_left_hand, new_pos_left_hand, sizeof(float) * 3);
1185  data_changed = true;
1186 }
1187 
1188 /** Set pos_left_hand value at given index.
1189  *
1190  Left hand position vector.
1191  * @param new_pos_left_hand new pos_left_hand value
1192  * @param index index for of the value
1193  */
1194 void
1195 HumanSkeletonInterface::set_pos_left_hand(unsigned int index, const float new_pos_left_hand)
1196 {
1197  if (index > 2) {
1198  throw Exception("Index value %u out of bounds (0..2)", index);
1199  }
1200  data->pos_left_hand[index] = new_pos_left_hand;
1202 }
1203 /** Get pos_left_hand_confidence value.
1204  *
1205  Left hand position confidence.
1206  * @return pos_left_hand_confidence value
1207  */
1208 float
1210 {
1211  return data->pos_left_hand_confidence;
1212 }
1213 
1214 /** Get maximum length of pos_left_hand_confidence value.
1215  * @return length of pos_left_hand_confidence value, can be length of the array or number of
1216  * maximum number of characters for a string
1217  */
1218 size_t
1220 {
1221  return 1;
1222 }
1223 
1224 /** Set pos_left_hand_confidence value.
1225  *
1226  Left hand position confidence.
1227  * @param new_pos_left_hand_confidence new pos_left_hand_confidence value
1228  */
1229 void
1230 HumanSkeletonInterface::set_pos_left_hand_confidence(const float new_pos_left_hand_confidence)
1231 {
1232  data->pos_left_hand_confidence = new_pos_left_hand_confidence;
1233  data_changed = true;
1234 }
1235 
1236 /** Get pos_left_fingertip value.
1237  *
1238  Left fingertip position vector.
1239  * @return pos_left_fingertip value
1240  */
1241 float *
1243 {
1244  return data->pos_left_fingertip;
1245 }
1246 
1247 /** Get pos_left_fingertip value at given index.
1248  *
1249  Left fingertip position vector.
1250  * @param index index of value
1251  * @return pos_left_fingertip value
1252  * @exception Exception thrown if index is out of bounds
1253  */
1254 float
1255 HumanSkeletonInterface::pos_left_fingertip(unsigned int index) const
1256 {
1257  if (index > 2) {
1258  throw Exception("Index value %u out of bounds (0..2)", index);
1259  }
1260  return data->pos_left_fingertip[index];
1262 
1263 /** Get maximum length of pos_left_fingertip value.
1264  * @return length of pos_left_fingertip value, can be length of the array or number of
1265  * maximum number of characters for a string
1266  */
1267 size_t
1269 {
1270  return 3;
1271 }
1272 
1273 /** Set pos_left_fingertip value.
1274  *
1275  Left fingertip position vector.
1276  * @param new_pos_left_fingertip new pos_left_fingertip value
1277  */
1278 void
1279 HumanSkeletonInterface::set_pos_left_fingertip(const float * new_pos_left_fingertip)
1280 {
1281  memcpy(data->pos_left_fingertip, new_pos_left_fingertip, sizeof(float) * 3);
1282  data_changed = true;
1283 }
1284 
1285 /** Set pos_left_fingertip value at given index.
1286  *
1287  Left fingertip position vector.
1288  * @param new_pos_left_fingertip new pos_left_fingertip value
1289  * @param index index for of the value
1290  */
1291 void
1292 HumanSkeletonInterface::set_pos_left_fingertip(unsigned int index, const float new_pos_left_fingertip)
1293 {
1294  if (index > 2) {
1295  throw Exception("Index value %u out of bounds (0..2)", index);
1296  }
1297  data->pos_left_fingertip[index] = new_pos_left_fingertip;
1299 }
1300 /** Get pos_left_fingertip_confidence value.
1301  *
1302  Left fingertip position confidence.
1303  * @return pos_left_fingertip_confidence value
1304  */
1305 float
1307 {
1308  return data->pos_left_fingertip_confidence;
1309 }
1310 
1311 /** Get maximum length of pos_left_fingertip_confidence value.
1312  * @return length of pos_left_fingertip_confidence value, can be length of the array or number of
1313  * maximum number of characters for a string
1314  */
1315 size_t
1317 {
1318  return 1;
1319 }
1320 
1321 /** Set pos_left_fingertip_confidence value.
1322  *
1323  Left fingertip position confidence.
1324  * @param new_pos_left_fingertip_confidence new pos_left_fingertip_confidence value
1325  */
1326 void
1327 HumanSkeletonInterface::set_pos_left_fingertip_confidence(const float new_pos_left_fingertip_confidence)
1328 {
1329  data->pos_left_fingertip_confidence = new_pos_left_fingertip_confidence;
1330  data_changed = true;
1331 }
1332 
1333 /** Get pos_right_collar value.
1334  *
1335  Right collar position vector.
1336  * @return pos_right_collar value
1337  */
1338 float *
1340 {
1341  return data->pos_right_collar;
1342 }
1343 
1344 /** Get pos_right_collar value at given index.
1345  *
1346  Right collar position vector.
1347  * @param index index of value
1348  * @return pos_right_collar value
1349  * @exception Exception thrown if index is out of bounds
1350  */
1351 float
1352 HumanSkeletonInterface::pos_right_collar(unsigned int index) const
1353 {
1354  if (index > 2) {
1355  throw Exception("Index value %u out of bounds (0..2)", index);
1356  }
1357  return data->pos_right_collar[index];
1359 
1360 /** Get maximum length of pos_right_collar value.
1361  * @return length of pos_right_collar value, can be length of the array or number of
1362  * maximum number of characters for a string
1363  */
1364 size_t
1366 {
1367  return 3;
1368 }
1369 
1370 /** Set pos_right_collar value.
1371  *
1372  Right collar position vector.
1373  * @param new_pos_right_collar new pos_right_collar value
1374  */
1375 void
1376 HumanSkeletonInterface::set_pos_right_collar(const float * new_pos_right_collar)
1377 {
1378  memcpy(data->pos_right_collar, new_pos_right_collar, sizeof(float) * 3);
1379  data_changed = true;
1380 }
1381 
1382 /** Set pos_right_collar value at given index.
1383  *
1384  Right collar position vector.
1385  * @param new_pos_right_collar new pos_right_collar value
1386  * @param index index for of the value
1387  */
1388 void
1389 HumanSkeletonInterface::set_pos_right_collar(unsigned int index, const float new_pos_right_collar)
1390 {
1391  if (index > 2) {
1392  throw Exception("Index value %u out of bounds (0..2)", index);
1393  }
1394  data->pos_right_collar[index] = new_pos_right_collar;
1396 }
1397 /** Get pos_right_collar_confidence value.
1398  *
1399  Right collar position confidence.
1400  * @return pos_right_collar_confidence value
1401  */
1402 float
1404 {
1405  return data->pos_right_collar_confidence;
1406 }
1407 
1408 /** Get maximum length of pos_right_collar_confidence value.
1409  * @return length of pos_right_collar_confidence value, can be length of the array or number of
1410  * maximum number of characters for a string
1411  */
1412 size_t
1414 {
1415  return 1;
1416 }
1417 
1418 /** Set pos_right_collar_confidence value.
1419  *
1420  Right collar position confidence.
1421  * @param new_pos_right_collar_confidence new pos_right_collar_confidence value
1422  */
1423 void
1424 HumanSkeletonInterface::set_pos_right_collar_confidence(const float new_pos_right_collar_confidence)
1425 {
1426  data->pos_right_collar_confidence = new_pos_right_collar_confidence;
1427  data_changed = true;
1428 }
1429 
1430 /** Get pos_right_shoulder value.
1431  *
1432  Right shoulder position vector.
1433  * @return pos_right_shoulder value
1434  */
1435 float *
1437 {
1438  return data->pos_right_shoulder;
1439 }
1440 
1441 /** Get pos_right_shoulder value at given index.
1442  *
1443  Right shoulder position vector.
1444  * @param index index of value
1445  * @return pos_right_shoulder value
1446  * @exception Exception thrown if index is out of bounds
1447  */
1448 float
1449 HumanSkeletonInterface::pos_right_shoulder(unsigned int index) const
1450 {
1451  if (index > 2) {
1452  throw Exception("Index value %u out of bounds (0..2)", index);
1453  }
1454  return data->pos_right_shoulder[index];
1456 
1457 /** Get maximum length of pos_right_shoulder value.
1458  * @return length of pos_right_shoulder value, can be length of the array or number of
1459  * maximum number of characters for a string
1460  */
1461 size_t
1463 {
1464  return 3;
1465 }
1466 
1467 /** Set pos_right_shoulder value.
1468  *
1469  Right shoulder position vector.
1470  * @param new_pos_right_shoulder new pos_right_shoulder value
1471  */
1472 void
1473 HumanSkeletonInterface::set_pos_right_shoulder(const float * new_pos_right_shoulder)
1474 {
1475  memcpy(data->pos_right_shoulder, new_pos_right_shoulder, sizeof(float) * 3);
1476  data_changed = true;
1477 }
1478 
1479 /** Set pos_right_shoulder value at given index.
1480  *
1481  Right shoulder position vector.
1482  * @param new_pos_right_shoulder new pos_right_shoulder value
1483  * @param index index for of the value
1484  */
1485 void
1486 HumanSkeletonInterface::set_pos_right_shoulder(unsigned int index, const float new_pos_right_shoulder)
1487 {
1488  if (index > 2) {
1489  throw Exception("Index value %u out of bounds (0..2)", index);
1490  }
1491  data->pos_right_shoulder[index] = new_pos_right_shoulder;
1493 }
1494 /** Get pos_right_shoulder_confidence value.
1495  *
1496  Right shoulder position confidence.
1497  * @return pos_right_shoulder_confidence value
1498  */
1499 float
1501 {
1502  return data->pos_right_shoulder_confidence;
1503 }
1504 
1505 /** Get maximum length of pos_right_shoulder_confidence value.
1506  * @return length of pos_right_shoulder_confidence value, can be length of the array or number of
1507  * maximum number of characters for a string
1508  */
1509 size_t
1511 {
1512  return 1;
1513 }
1514 
1515 /** Set pos_right_shoulder_confidence value.
1516  *
1517  Right shoulder position confidence.
1518  * @param new_pos_right_shoulder_confidence new pos_right_shoulder_confidence value
1519  */
1520 void
1521 HumanSkeletonInterface::set_pos_right_shoulder_confidence(const float new_pos_right_shoulder_confidence)
1522 {
1523  data->pos_right_shoulder_confidence = new_pos_right_shoulder_confidence;
1524  data_changed = true;
1525 }
1526 
1527 /** Get pos_right_elbow value.
1528  *
1529  Right elbow position vector.
1530  * @return pos_right_elbow value
1531  */
1532 float *
1534 {
1535  return data->pos_right_elbow;
1536 }
1537 
1538 /** Get pos_right_elbow value at given index.
1539  *
1540  Right elbow position vector.
1541  * @param index index of value
1542  * @return pos_right_elbow value
1543  * @exception Exception thrown if index is out of bounds
1544  */
1545 float
1546 HumanSkeletonInterface::pos_right_elbow(unsigned int index) const
1547 {
1548  if (index > 2) {
1549  throw Exception("Index value %u out of bounds (0..2)", index);
1550  }
1551  return data->pos_right_elbow[index];
1553 
1554 /** Get maximum length of pos_right_elbow value.
1555  * @return length of pos_right_elbow value, can be length of the array or number of
1556  * maximum number of characters for a string
1557  */
1558 size_t
1560 {
1561  return 3;
1562 }
1563 
1564 /** Set pos_right_elbow value.
1565  *
1566  Right elbow position vector.
1567  * @param new_pos_right_elbow new pos_right_elbow value
1568  */
1569 void
1570 HumanSkeletonInterface::set_pos_right_elbow(const float * new_pos_right_elbow)
1571 {
1572  memcpy(data->pos_right_elbow, new_pos_right_elbow, sizeof(float) * 3);
1573  data_changed = true;
1574 }
1575 
1576 /** Set pos_right_elbow value at given index.
1577  *
1578  Right elbow position vector.
1579  * @param new_pos_right_elbow new pos_right_elbow value
1580  * @param index index for of the value
1581  */
1582 void
1583 HumanSkeletonInterface::set_pos_right_elbow(unsigned int index, const float new_pos_right_elbow)
1584 {
1585  if (index > 2) {
1586  throw Exception("Index value %u out of bounds (0..2)", index);
1587  }
1588  data->pos_right_elbow[index] = new_pos_right_elbow;
1590 }
1591 /** Get pos_right_elbow_confidence value.
1592  *
1593  Right elbow position confidence.
1594  * @return pos_right_elbow_confidence value
1595  */
1596 float
1598 {
1599  return data->pos_right_elbow_confidence;
1600 }
1601 
1602 /** Get maximum length of pos_right_elbow_confidence value.
1603  * @return length of pos_right_elbow_confidence value, can be length of the array or number of
1604  * maximum number of characters for a string
1605  */
1606 size_t
1608 {
1609  return 1;
1610 }
1611 
1612 /** Set pos_right_elbow_confidence value.
1613  *
1614  Right elbow position confidence.
1615  * @param new_pos_right_elbow_confidence new pos_right_elbow_confidence value
1616  */
1617 void
1618 HumanSkeletonInterface::set_pos_right_elbow_confidence(const float new_pos_right_elbow_confidence)
1619 {
1620  data->pos_right_elbow_confidence = new_pos_right_elbow_confidence;
1621  data_changed = true;
1622 }
1623 
1624 /** Get pos_right_wrist value.
1625  *
1626  Right wrist position vector.
1627  * @return pos_right_wrist value
1628  */
1629 float *
1631 {
1632  return data->pos_right_wrist;
1633 }
1634 
1635 /** Get pos_right_wrist value at given index.
1636  *
1637  Right wrist position vector.
1638  * @param index index of value
1639  * @return pos_right_wrist value
1640  * @exception Exception thrown if index is out of bounds
1641  */
1642 float
1643 HumanSkeletonInterface::pos_right_wrist(unsigned int index) const
1644 {
1645  if (index > 2) {
1646  throw Exception("Index value %u out of bounds (0..2)", index);
1647  }
1648  return data->pos_right_wrist[index];
1650 
1651 /** Get maximum length of pos_right_wrist value.
1652  * @return length of pos_right_wrist value, can be length of the array or number of
1653  * maximum number of characters for a string
1654  */
1655 size_t
1657 {
1658  return 3;
1659 }
1660 
1661 /** Set pos_right_wrist value.
1662  *
1663  Right wrist position vector.
1664  * @param new_pos_right_wrist new pos_right_wrist value
1665  */
1666 void
1667 HumanSkeletonInterface::set_pos_right_wrist(const float * new_pos_right_wrist)
1668 {
1669  memcpy(data->pos_right_wrist, new_pos_right_wrist, sizeof(float) * 3);
1670  data_changed = true;
1671 }
1672 
1673 /** Set pos_right_wrist value at given index.
1674  *
1675  Right wrist position vector.
1676  * @param new_pos_right_wrist new pos_right_wrist value
1677  * @param index index for of the value
1678  */
1679 void
1680 HumanSkeletonInterface::set_pos_right_wrist(unsigned int index, const float new_pos_right_wrist)
1681 {
1682  if (index > 2) {
1683  throw Exception("Index value %u out of bounds (0..2)", index);
1684  }
1685  data->pos_right_wrist[index] = new_pos_right_wrist;
1687 }
1688 /** Get pos_right_wrist_confidence value.
1689  *
1690  Right wrist position confidence.
1691  * @return pos_right_wrist_confidence value
1692  */
1693 float
1695 {
1696  return data->pos_right_wrist_confidence;
1697 }
1698 
1699 /** Get maximum length of pos_right_wrist_confidence value.
1700  * @return length of pos_right_wrist_confidence value, can be length of the array or number of
1701  * maximum number of characters for a string
1702  */
1703 size_t
1705 {
1706  return 1;
1707 }
1708 
1709 /** Set pos_right_wrist_confidence value.
1710  *
1711  Right wrist position confidence.
1712  * @param new_pos_right_wrist_confidence new pos_right_wrist_confidence value
1713  */
1714 void
1715 HumanSkeletonInterface::set_pos_right_wrist_confidence(const float new_pos_right_wrist_confidence)
1716 {
1717  data->pos_right_wrist_confidence = new_pos_right_wrist_confidence;
1718  data_changed = true;
1719 }
1720 
1721 /** Get pos_right_hand value.
1722  *
1723  Right hand position vector.
1724  * @return pos_right_hand value
1725  */
1726 float *
1728 {
1729  return data->pos_right_hand;
1730 }
1731 
1732 /** Get pos_right_hand value at given index.
1733  *
1734  Right hand position vector.
1735  * @param index index of value
1736  * @return pos_right_hand value
1737  * @exception Exception thrown if index is out of bounds
1738  */
1739 float
1740 HumanSkeletonInterface::pos_right_hand(unsigned int index) const
1741 {
1742  if (index > 2) {
1743  throw Exception("Index value %u out of bounds (0..2)", index);
1744  }
1745  return data->pos_right_hand[index];
1747 
1748 /** Get maximum length of pos_right_hand value.
1749  * @return length of pos_right_hand value, can be length of the array or number of
1750  * maximum number of characters for a string
1751  */
1752 size_t
1754 {
1755  return 3;
1756 }
1757 
1758 /** Set pos_right_hand value.
1759  *
1760  Right hand position vector.
1761  * @param new_pos_right_hand new pos_right_hand value
1762  */
1763 void
1764 HumanSkeletonInterface::set_pos_right_hand(const float * new_pos_right_hand)
1765 {
1766  memcpy(data->pos_right_hand, new_pos_right_hand, sizeof(float) * 3);
1767  data_changed = true;
1768 }
1769 
1770 /** Set pos_right_hand value at given index.
1771  *
1772  Right hand position vector.
1773  * @param new_pos_right_hand new pos_right_hand value
1774  * @param index index for of the value
1775  */
1776 void
1777 HumanSkeletonInterface::set_pos_right_hand(unsigned int index, const float new_pos_right_hand)
1778 {
1779  if (index > 2) {
1780  throw Exception("Index value %u out of bounds (0..2)", index);
1781  }
1782  data->pos_right_hand[index] = new_pos_right_hand;
1784 }
1785 /** Get pos_right_hand_confidence value.
1786  *
1787  Right hand position confidence.
1788  * @return pos_right_hand_confidence value
1789  */
1790 float
1792 {
1793  return data->pos_right_hand_confidence;
1794 }
1795 
1796 /** Get maximum length of pos_right_hand_confidence value.
1797  * @return length of pos_right_hand_confidence value, can be length of the array or number of
1798  * maximum number of characters for a string
1799  */
1800 size_t
1802 {
1803  return 1;
1804 }
1805 
1806 /** Set pos_right_hand_confidence value.
1807  *
1808  Right hand position confidence.
1809  * @param new_pos_right_hand_confidence new pos_right_hand_confidence value
1810  */
1811 void
1812 HumanSkeletonInterface::set_pos_right_hand_confidence(const float new_pos_right_hand_confidence)
1813 {
1814  data->pos_right_hand_confidence = new_pos_right_hand_confidence;
1815  data_changed = true;
1816 }
1817 
1818 /** Get pos_right_fingertip value.
1819  *
1820  Right fingertip position vector.
1821  * @return pos_right_fingertip value
1822  */
1823 float *
1825 {
1826  return data->pos_right_fingertip;
1827 }
1828 
1829 /** Get pos_right_fingertip value at given index.
1830  *
1831  Right fingertip position vector.
1832  * @param index index of value
1833  * @return pos_right_fingertip value
1834  * @exception Exception thrown if index is out of bounds
1835  */
1836 float
1837 HumanSkeletonInterface::pos_right_fingertip(unsigned int index) const
1838 {
1839  if (index > 2) {
1840  throw Exception("Index value %u out of bounds (0..2)", index);
1841  }
1842  return data->pos_right_fingertip[index];
1844 
1845 /** Get maximum length of pos_right_fingertip value.
1846  * @return length of pos_right_fingertip value, can be length of the array or number of
1847  * maximum number of characters for a string
1848  */
1849 size_t
1851 {
1852  return 3;
1853 }
1854 
1855 /** Set pos_right_fingertip value.
1856  *
1857  Right fingertip position vector.
1858  * @param new_pos_right_fingertip new pos_right_fingertip value
1859  */
1860 void
1861 HumanSkeletonInterface::set_pos_right_fingertip(const float * new_pos_right_fingertip)
1862 {
1863  memcpy(data->pos_right_fingertip, new_pos_right_fingertip, sizeof(float) * 3);
1864  data_changed = true;
1865 }
1866 
1867 /** Set pos_right_fingertip value at given index.
1868  *
1869  Right fingertip position vector.
1870  * @param new_pos_right_fingertip new pos_right_fingertip value
1871  * @param index index for of the value
1872  */
1873 void
1874 HumanSkeletonInterface::set_pos_right_fingertip(unsigned int index, const float new_pos_right_fingertip)
1875 {
1876  if (index > 2) {
1877  throw Exception("Index value %u out of bounds (0..2)", index);
1878  }
1879  data->pos_right_fingertip[index] = new_pos_right_fingertip;
1881 }
1882 /** Get pos_right_fingertip_confidence value.
1883  *
1884  Right fingertip position confidence.
1885  * @return pos_right_fingertip_confidence value
1886  */
1887 float
1889 {
1890  return data->pos_right_fingertip_confidence;
1891 }
1892 
1893 /** Get maximum length of pos_right_fingertip_confidence value.
1894  * @return length of pos_right_fingertip_confidence value, can be length of the array or number of
1895  * maximum number of characters for a string
1896  */
1897 size_t
1899 {
1900  return 1;
1901 }
1902 
1903 /** Set pos_right_fingertip_confidence value.
1904  *
1905  Right fingertip position confidence.
1906  * @param new_pos_right_fingertip_confidence new pos_right_fingertip_confidence value
1907  */
1908 void
1909 HumanSkeletonInterface::set_pos_right_fingertip_confidence(const float new_pos_right_fingertip_confidence)
1910 {
1911  data->pos_right_fingertip_confidence = new_pos_right_fingertip_confidence;
1912  data_changed = true;
1913 }
1914 
1915 /** Get pos_left_hip value.
1916  *
1917  Left hip position vector.
1918  * @return pos_left_hip value
1919  */
1920 float *
1922 {
1923  return data->pos_left_hip;
1924 }
1925 
1926 /** Get pos_left_hip value at given index.
1927  *
1928  Left hip position vector.
1929  * @param index index of value
1930  * @return pos_left_hip value
1931  * @exception Exception thrown if index is out of bounds
1932  */
1933 float
1934 HumanSkeletonInterface::pos_left_hip(unsigned int index) const
1935 {
1936  if (index > 2) {
1937  throw Exception("Index value %u out of bounds (0..2)", index);
1938  }
1939  return data->pos_left_hip[index];
1941 
1942 /** Get maximum length of pos_left_hip value.
1943  * @return length of pos_left_hip value, can be length of the array or number of
1944  * maximum number of characters for a string
1945  */
1946 size_t
1948 {
1949  return 3;
1950 }
1951 
1952 /** Set pos_left_hip value.
1953  *
1954  Left hip position vector.
1955  * @param new_pos_left_hip new pos_left_hip value
1956  */
1957 void
1958 HumanSkeletonInterface::set_pos_left_hip(const float * new_pos_left_hip)
1959 {
1960  memcpy(data->pos_left_hip, new_pos_left_hip, sizeof(float) * 3);
1961  data_changed = true;
1962 }
1963 
1964 /** Set pos_left_hip value at given index.
1965  *
1966  Left hip position vector.
1967  * @param new_pos_left_hip new pos_left_hip value
1968  * @param index index for of the value
1969  */
1970 void
1971 HumanSkeletonInterface::set_pos_left_hip(unsigned int index, const float new_pos_left_hip)
1972 {
1973  if (index > 2) {
1974  throw Exception("Index value %u out of bounds (0..2)", index);
1975  }
1976  data->pos_left_hip[index] = new_pos_left_hip;
1978 }
1979 /** Get pos_left_hip_confidence value.
1980  *
1981  Left hip position confidence.
1982  * @return pos_left_hip_confidence value
1983  */
1984 float
1986 {
1987  return data->pos_left_hip_confidence;
1988 }
1989 
1990 /** Get maximum length of pos_left_hip_confidence value.
1991  * @return length of pos_left_hip_confidence value, can be length of the array or number of
1992  * maximum number of characters for a string
1993  */
1994 size_t
1996 {
1997  return 1;
1998 }
1999 
2000 /** Set pos_left_hip_confidence value.
2001  *
2002  Left hip position confidence.
2003  * @param new_pos_left_hip_confidence new pos_left_hip_confidence value
2004  */
2005 void
2006 HumanSkeletonInterface::set_pos_left_hip_confidence(const float new_pos_left_hip_confidence)
2007 {
2008  data->pos_left_hip_confidence = new_pos_left_hip_confidence;
2009  data_changed = true;
2010 }
2011 
2012 /** Get pos_left_knee value.
2013  *
2014  Left knee position vector.
2015  * @return pos_left_knee value
2016  */
2017 float *
2019 {
2020  return data->pos_left_knee;
2021 }
2022 
2023 /** Get pos_left_knee value at given index.
2024  *
2025  Left knee position vector.
2026  * @param index index of value
2027  * @return pos_left_knee value
2028  * @exception Exception thrown if index is out of bounds
2029  */
2030 float
2031 HumanSkeletonInterface::pos_left_knee(unsigned int index) const
2032 {
2033  if (index > 2) {
2034  throw Exception("Index value %u out of bounds (0..2)", index);
2035  }
2036  return data->pos_left_knee[index];
2038 
2039 /** Get maximum length of pos_left_knee value.
2040  * @return length of pos_left_knee value, can be length of the array or number of
2041  * maximum number of characters for a string
2042  */
2043 size_t
2045 {
2046  return 3;
2047 }
2048 
2049 /** Set pos_left_knee value.
2050  *
2051  Left knee position vector.
2052  * @param new_pos_left_knee new pos_left_knee value
2053  */
2054 void
2055 HumanSkeletonInterface::set_pos_left_knee(const float * new_pos_left_knee)
2056 {
2057  memcpy(data->pos_left_knee, new_pos_left_knee, sizeof(float) * 3);
2058  data_changed = true;
2059 }
2060 
2061 /** Set pos_left_knee value at given index.
2062  *
2063  Left knee position vector.
2064  * @param new_pos_left_knee new pos_left_knee value
2065  * @param index index for of the value
2066  */
2067 void
2068 HumanSkeletonInterface::set_pos_left_knee(unsigned int index, const float new_pos_left_knee)
2069 {
2070  if (index > 2) {
2071  throw Exception("Index value %u out of bounds (0..2)", index);
2072  }
2073  data->pos_left_knee[index] = new_pos_left_knee;
2075 }
2076 /** Get pos_left_knee_confidence value.
2077  *
2078  Left knee position confidence.
2079  * @return pos_left_knee_confidence value
2080  */
2081 float
2083 {
2084  return data->pos_left_knee_confidence;
2085 }
2086 
2087 /** Get maximum length of pos_left_knee_confidence value.
2088  * @return length of pos_left_knee_confidence value, can be length of the array or number of
2089  * maximum number of characters for a string
2090  */
2091 size_t
2093 {
2094  return 1;
2095 }
2096 
2097 /** Set pos_left_knee_confidence value.
2098  *
2099  Left knee position confidence.
2100  * @param new_pos_left_knee_confidence new pos_left_knee_confidence value
2101  */
2102 void
2103 HumanSkeletonInterface::set_pos_left_knee_confidence(const float new_pos_left_knee_confidence)
2104 {
2105  data->pos_left_knee_confidence = new_pos_left_knee_confidence;
2106  data_changed = true;
2107 }
2108 
2109 /** Get pos_left_ankle value.
2110  *
2111  Left ankle position vector.
2112  * @return pos_left_ankle value
2113  */
2114 float *
2116 {
2117  return data->pos_left_ankle;
2118 }
2119 
2120 /** Get pos_left_ankle value at given index.
2121  *
2122  Left ankle position vector.
2123  * @param index index of value
2124  * @return pos_left_ankle value
2125  * @exception Exception thrown if index is out of bounds
2126  */
2127 float
2128 HumanSkeletonInterface::pos_left_ankle(unsigned int index) const
2129 {
2130  if (index > 2) {
2131  throw Exception("Index value %u out of bounds (0..2)", index);
2132  }
2133  return data->pos_left_ankle[index];
2135 
2136 /** Get maximum length of pos_left_ankle value.
2137  * @return length of pos_left_ankle value, can be length of the array or number of
2138  * maximum number of characters for a string
2139  */
2140 size_t
2142 {
2143  return 3;
2144 }
2145 
2146 /** Set pos_left_ankle value.
2147  *
2148  Left ankle position vector.
2149  * @param new_pos_left_ankle new pos_left_ankle value
2150  */
2151 void
2152 HumanSkeletonInterface::set_pos_left_ankle(const float * new_pos_left_ankle)
2153 {
2154  memcpy(data->pos_left_ankle, new_pos_left_ankle, sizeof(float) * 3);
2155  data_changed = true;
2156 }
2157 
2158 /** Set pos_left_ankle value at given index.
2159  *
2160  Left ankle position vector.
2161  * @param new_pos_left_ankle new pos_left_ankle value
2162  * @param index index for of the value
2163  */
2164 void
2165 HumanSkeletonInterface::set_pos_left_ankle(unsigned int index, const float new_pos_left_ankle)
2166 {
2167  if (index > 2) {
2168  throw Exception("Index value %u out of bounds (0..2)", index);
2169  }
2170  data->pos_left_ankle[index] = new_pos_left_ankle;
2172 }
2173 /** Get pos_left_ankle_confidence value.
2174  *
2175  Left ankle position confidence.
2176  * @return pos_left_ankle_confidence value
2177  */
2178 float
2180 {
2181  return data->pos_left_ankle_confidence;
2182 }
2183 
2184 /** Get maximum length of pos_left_ankle_confidence value.
2185  * @return length of pos_left_ankle_confidence value, can be length of the array or number of
2186  * maximum number of characters for a string
2187  */
2188 size_t
2190 {
2191  return 1;
2192 }
2193 
2194 /** Set pos_left_ankle_confidence value.
2195  *
2196  Left ankle position confidence.
2197  * @param new_pos_left_ankle_confidence new pos_left_ankle_confidence value
2198  */
2199 void
2200 HumanSkeletonInterface::set_pos_left_ankle_confidence(const float new_pos_left_ankle_confidence)
2201 {
2202  data->pos_left_ankle_confidence = new_pos_left_ankle_confidence;
2203  data_changed = true;
2204 }
2205 
2206 /** Get pos_left_foot value.
2207  *
2208  Left foot position vector.
2209  * @return pos_left_foot value
2210  */
2211 float *
2213 {
2214  return data->pos_left_foot;
2215 }
2216 
2217 /** Get pos_left_foot value at given index.
2218  *
2219  Left foot position vector.
2220  * @param index index of value
2221  * @return pos_left_foot value
2222  * @exception Exception thrown if index is out of bounds
2223  */
2224 float
2225 HumanSkeletonInterface::pos_left_foot(unsigned int index) const
2226 {
2227  if (index > 2) {
2228  throw Exception("Index value %u out of bounds (0..2)", index);
2229  }
2230  return data->pos_left_foot[index];
2232 
2233 /** Get maximum length of pos_left_foot value.
2234  * @return length of pos_left_foot value, can be length of the array or number of
2235  * maximum number of characters for a string
2236  */
2237 size_t
2239 {
2240  return 3;
2241 }
2242 
2243 /** Set pos_left_foot value.
2244  *
2245  Left foot position vector.
2246  * @param new_pos_left_foot new pos_left_foot value
2247  */
2248 void
2249 HumanSkeletonInterface::set_pos_left_foot(const float * new_pos_left_foot)
2250 {
2251  memcpy(data->pos_left_foot, new_pos_left_foot, sizeof(float) * 3);
2252  data_changed = true;
2253 }
2254 
2255 /** Set pos_left_foot value at given index.
2256  *
2257  Left foot position vector.
2258  * @param new_pos_left_foot new pos_left_foot value
2259  * @param index index for of the value
2260  */
2261 void
2262 HumanSkeletonInterface::set_pos_left_foot(unsigned int index, const float new_pos_left_foot)
2263 {
2264  if (index > 2) {
2265  throw Exception("Index value %u out of bounds (0..2)", index);
2266  }
2267  data->pos_left_foot[index] = new_pos_left_foot;
2269 }
2270 /** Get pos_left_foot_confidence value.
2271  *
2272  Left foot position confidence.
2273  * @return pos_left_foot_confidence value
2274  */
2275 float
2277 {
2278  return data->pos_left_foot_confidence;
2279 }
2280 
2281 /** Get maximum length of pos_left_foot_confidence value.
2282  * @return length of pos_left_foot_confidence value, can be length of the array or number of
2283  * maximum number of characters for a string
2284  */
2285 size_t
2287 {
2288  return 1;
2289 }
2290 
2291 /** Set pos_left_foot_confidence value.
2292  *
2293  Left foot position confidence.
2294  * @param new_pos_left_foot_confidence new pos_left_foot_confidence value
2295  */
2296 void
2297 HumanSkeletonInterface::set_pos_left_foot_confidence(const float new_pos_left_foot_confidence)
2298 {
2299  data->pos_left_foot_confidence = new_pos_left_foot_confidence;
2300  data_changed = true;
2301 }
2302 
2303 /** Get pos_right_hip value.
2304  *
2305  Right hip position vector.
2306  * @return pos_right_hip value
2307  */
2308 float *
2310 {
2311  return data->pos_right_hip;
2312 }
2313 
2314 /** Get pos_right_hip value at given index.
2315  *
2316  Right hip position vector.
2317  * @param index index of value
2318  * @return pos_right_hip value
2319  * @exception Exception thrown if index is out of bounds
2320  */
2321 float
2322 HumanSkeletonInterface::pos_right_hip(unsigned int index) const
2323 {
2324  if (index > 2) {
2325  throw Exception("Index value %u out of bounds (0..2)", index);
2326  }
2327  return data->pos_right_hip[index];
2329 
2330 /** Get maximum length of pos_right_hip value.
2331  * @return length of pos_right_hip value, can be length of the array or number of
2332  * maximum number of characters for a string
2333  */
2334 size_t
2336 {
2337  return 3;
2338 }
2339 
2340 /** Set pos_right_hip value.
2341  *
2342  Right hip position vector.
2343  * @param new_pos_right_hip new pos_right_hip value
2344  */
2345 void
2346 HumanSkeletonInterface::set_pos_right_hip(const float * new_pos_right_hip)
2347 {
2348  memcpy(data->pos_right_hip, new_pos_right_hip, sizeof(float) * 3);
2349  data_changed = true;
2350 }
2351 
2352 /** Set pos_right_hip value at given index.
2353  *
2354  Right hip position vector.
2355  * @param new_pos_right_hip new pos_right_hip value
2356  * @param index index for of the value
2357  */
2358 void
2359 HumanSkeletonInterface::set_pos_right_hip(unsigned int index, const float new_pos_right_hip)
2360 {
2361  if (index > 2) {
2362  throw Exception("Index value %u out of bounds (0..2)", index);
2363  }
2364  data->pos_right_hip[index] = new_pos_right_hip;
2366 }
2367 /** Get pos_right_hip_confidence value.
2368  *
2369  Right hip position confidence.
2370  * @return pos_right_hip_confidence value
2371  */
2372 float
2374 {
2375  return data->pos_right_hip_confidence;
2376 }
2377 
2378 /** Get maximum length of pos_right_hip_confidence value.
2379  * @return length of pos_right_hip_confidence value, can be length of the array or number of
2380  * maximum number of characters for a string
2381  */
2382 size_t
2384 {
2385  return 1;
2386 }
2387 
2388 /** Set pos_right_hip_confidence value.
2389  *
2390  Right hip position confidence.
2391  * @param new_pos_right_hip_confidence new pos_right_hip_confidence value
2392  */
2393 void
2394 HumanSkeletonInterface::set_pos_right_hip_confidence(const float new_pos_right_hip_confidence)
2395 {
2396  data->pos_right_hip_confidence = new_pos_right_hip_confidence;
2397  data_changed = true;
2398 }
2399 
2400 /** Get pos_right_knee value.
2401  *
2402  Right knee position vector.
2403  * @return pos_right_knee value
2404  */
2405 float *
2407 {
2408  return data->pos_right_knee;
2409 }
2410 
2411 /** Get pos_right_knee value at given index.
2412  *
2413  Right knee position vector.
2414  * @param index index of value
2415  * @return pos_right_knee value
2416  * @exception Exception thrown if index is out of bounds
2417  */
2418 float
2419 HumanSkeletonInterface::pos_right_knee(unsigned int index) const
2420 {
2421  if (index > 2) {
2422  throw Exception("Index value %u out of bounds (0..2)", index);
2423  }
2424  return data->pos_right_knee[index];
2426 
2427 /** Get maximum length of pos_right_knee value.
2428  * @return length of pos_right_knee value, can be length of the array or number of
2429  * maximum number of characters for a string
2430  */
2431 size_t
2433 {
2434  return 3;
2435 }
2436 
2437 /** Set pos_right_knee value.
2438  *
2439  Right knee position vector.
2440  * @param new_pos_right_knee new pos_right_knee value
2441  */
2442 void
2443 HumanSkeletonInterface::set_pos_right_knee(const float * new_pos_right_knee)
2444 {
2445  memcpy(data->pos_right_knee, new_pos_right_knee, sizeof(float) * 3);
2446  data_changed = true;
2447 }
2448 
2449 /** Set pos_right_knee value at given index.
2450  *
2451  Right knee position vector.
2452  * @param new_pos_right_knee new pos_right_knee value
2453  * @param index index for of the value
2454  */
2455 void
2456 HumanSkeletonInterface::set_pos_right_knee(unsigned int index, const float new_pos_right_knee)
2457 {
2458  if (index > 2) {
2459  throw Exception("Index value %u out of bounds (0..2)", index);
2460  }
2461  data->pos_right_knee[index] = new_pos_right_knee;
2463 }
2464 /** Get pos_right_knee_confidence value.
2465  *
2466  Right knee position confidence.
2467  * @return pos_right_knee_confidence value
2468  */
2469 float
2471 {
2472  return data->pos_right_knee_confidence;
2473 }
2474 
2475 /** Get maximum length of pos_right_knee_confidence value.
2476  * @return length of pos_right_knee_confidence value, can be length of the array or number of
2477  * maximum number of characters for a string
2478  */
2479 size_t
2481 {
2482  return 1;
2483 }
2484 
2485 /** Set pos_right_knee_confidence value.
2486  *
2487  Right knee position confidence.
2488  * @param new_pos_right_knee_confidence new pos_right_knee_confidence value
2489  */
2490 void
2491 HumanSkeletonInterface::set_pos_right_knee_confidence(const float new_pos_right_knee_confidence)
2492 {
2493  data->pos_right_knee_confidence = new_pos_right_knee_confidence;
2494  data_changed = true;
2495 }
2496 
2497 /** Get pos_right_ankle value.
2498  *
2499  Right ankle position vector.
2500  * @return pos_right_ankle value
2501  */
2502 float *
2504 {
2505  return data->pos_right_ankle;
2506 }
2507 
2508 /** Get pos_right_ankle value at given index.
2509  *
2510  Right ankle position vector.
2511  * @param index index of value
2512  * @return pos_right_ankle value
2513  * @exception Exception thrown if index is out of bounds
2514  */
2515 float
2516 HumanSkeletonInterface::pos_right_ankle(unsigned int index) const
2517 {
2518  if (index > 2) {
2519  throw Exception("Index value %u out of bounds (0..2)", index);
2520  }
2521  return data->pos_right_ankle[index];
2523 
2524 /** Get maximum length of pos_right_ankle value.
2525  * @return length of pos_right_ankle value, can be length of the array or number of
2526  * maximum number of characters for a string
2527  */
2528 size_t
2530 {
2531  return 3;
2532 }
2533 
2534 /** Set pos_right_ankle value.
2535  *
2536  Right ankle position vector.
2537  * @param new_pos_right_ankle new pos_right_ankle value
2538  */
2539 void
2540 HumanSkeletonInterface::set_pos_right_ankle(const float * new_pos_right_ankle)
2541 {
2542  memcpy(data->pos_right_ankle, new_pos_right_ankle, sizeof(float) * 3);
2543  data_changed = true;
2544 }
2545 
2546 /** Set pos_right_ankle value at given index.
2547  *
2548  Right ankle position vector.
2549  * @param new_pos_right_ankle new pos_right_ankle value
2550  * @param index index for of the value
2551  */
2552 void
2553 HumanSkeletonInterface::set_pos_right_ankle(unsigned int index, const float new_pos_right_ankle)
2554 {
2555  if (index > 2) {
2556  throw Exception("Index value %u out of bounds (0..2)", index);
2557  }
2558  data->pos_right_ankle[index] = new_pos_right_ankle;
2560 }
2561 /** Get pos_right_ankle_confidence value.
2562  *
2563  Right ankle position confidence.
2564  * @return pos_right_ankle_confidence value
2565  */
2566 float
2568 {
2569  return data->pos_right_ankle_confidence;
2570 }
2571 
2572 /** Get maximum length of pos_right_ankle_confidence value.
2573  * @return length of pos_right_ankle_confidence value, can be length of the array or number of
2574  * maximum number of characters for a string
2575  */
2576 size_t
2578 {
2579  return 1;
2580 }
2581 
2582 /** Set pos_right_ankle_confidence value.
2583  *
2584  Right ankle position confidence.
2585  * @param new_pos_right_ankle_confidence new pos_right_ankle_confidence value
2586  */
2587 void
2588 HumanSkeletonInterface::set_pos_right_ankle_confidence(const float new_pos_right_ankle_confidence)
2589 {
2590  data->pos_right_ankle_confidence = new_pos_right_ankle_confidence;
2591  data_changed = true;
2592 }
2593 
2594 /** Get pos_right_foot value.
2595  *
2596  Right foot position vector.
2597  * @return pos_right_foot value
2598  */
2599 float *
2601 {
2602  return data->pos_right_foot;
2603 }
2604 
2605 /** Get pos_right_foot value at given index.
2606  *
2607  Right foot position vector.
2608  * @param index index of value
2609  * @return pos_right_foot value
2610  * @exception Exception thrown if index is out of bounds
2611  */
2612 float
2613 HumanSkeletonInterface::pos_right_foot(unsigned int index) const
2614 {
2615  if (index > 2) {
2616  throw Exception("Index value %u out of bounds (0..2)", index);
2617  }
2618  return data->pos_right_foot[index];
2620 
2621 /** Get maximum length of pos_right_foot value.
2622  * @return length of pos_right_foot value, can be length of the array or number of
2623  * maximum number of characters for a string
2624  */
2625 size_t
2627 {
2628  return 3;
2629 }
2630 
2631 /** Set pos_right_foot value.
2632  *
2633  Right foot position vector.
2634  * @param new_pos_right_foot new pos_right_foot value
2635  */
2636 void
2637 HumanSkeletonInterface::set_pos_right_foot(const float * new_pos_right_foot)
2638 {
2639  memcpy(data->pos_right_foot, new_pos_right_foot, sizeof(float) * 3);
2640  data_changed = true;
2641 }
2642 
2643 /** Set pos_right_foot value at given index.
2644  *
2645  Right foot position vector.
2646  * @param new_pos_right_foot new pos_right_foot value
2647  * @param index index for of the value
2648  */
2649 void
2650 HumanSkeletonInterface::set_pos_right_foot(unsigned int index, const float new_pos_right_foot)
2651 {
2652  if (index > 2) {
2653  throw Exception("Index value %u out of bounds (0..2)", index);
2654  }
2655  data->pos_right_foot[index] = new_pos_right_foot;
2657 }
2658 /** Get pos_right_foot_confidence value.
2659  *
2660  Right foot position confidence.
2661  * @return pos_right_foot_confidence value
2662  */
2663 float
2665 {
2666  return data->pos_right_foot_confidence;
2667 }
2668 
2669 /** Get maximum length of pos_right_foot_confidence value.
2670  * @return length of pos_right_foot_confidence value, can be length of the array or number of
2671  * maximum number of characters for a string
2672  */
2673 size_t
2675 {
2676  return 1;
2677 }
2678 
2679 /** Set pos_right_foot_confidence value.
2680  *
2681  Right foot position confidence.
2682  * @param new_pos_right_foot_confidence new pos_right_foot_confidence value
2683  */
2684 void
2685 HumanSkeletonInterface::set_pos_right_foot_confidence(const float new_pos_right_foot_confidence)
2686 {
2687  data->pos_right_foot_confidence = new_pos_right_foot_confidence;
2688  data_changed = true;
2689 }
2690 
2691 /** Get ori_head value.
2692  * Head position vector.
2693  * @return ori_head value
2694  */
2695 float *
2697 {
2698  return data->ori_head;
2699 }
2700 
2701 /** Get ori_head value at given index.
2702  * Head position vector.
2703  * @param index index of value
2704  * @return ori_head value
2705  * @exception Exception thrown if index is out of bounds
2706  */
2707 float
2708 HumanSkeletonInterface::ori_head(unsigned int index) const
2709 {
2710  if (index > 8) {
2711  throw Exception("Index value %u out of bounds (0..8)", index);
2712  }
2713  return data->ori_head[index];
2715 
2716 /** Get maximum length of ori_head value.
2717  * @return length of ori_head value, can be length of the array or number of
2718  * maximum number of characters for a string
2719  */
2720 size_t
2722 {
2723  return 9;
2724 }
2725 
2726 /** Set ori_head value.
2727  * Head position vector.
2728  * @param new_ori_head new ori_head value
2729  */
2730 void
2731 HumanSkeletonInterface::set_ori_head(const float * new_ori_head)
2732 {
2733  memcpy(data->ori_head, new_ori_head, sizeof(float) * 9);
2734  data_changed = true;
2735 }
2736 
2737 /** Set ori_head value at given index.
2738  * Head position vector.
2739  * @param new_ori_head new ori_head value
2740  * @param index index for of the value
2741  */
2742 void
2743 HumanSkeletonInterface::set_ori_head(unsigned int index, const float new_ori_head)
2744 {
2745  if (index > 8) {
2746  throw Exception("Index value %u out of bounds (0..8)", index);
2747  }
2748  data->ori_head[index] = new_ori_head;
2750 }
2751 /** Get ori_head_confidence value.
2752  *
2753  Head position confidence.
2754  * @return ori_head_confidence value
2755  */
2756 float
2758 {
2759  return data->ori_head_confidence;
2760 }
2761 
2762 /** Get maximum length of ori_head_confidence value.
2763  * @return length of ori_head_confidence value, can be length of the array or number of
2764  * maximum number of characters for a string
2765  */
2766 size_t
2768 {
2769  return 1;
2770 }
2771 
2772 /** Set ori_head_confidence value.
2773  *
2774  Head position confidence.
2775  * @param new_ori_head_confidence new ori_head_confidence value
2776  */
2777 void
2778 HumanSkeletonInterface::set_ori_head_confidence(const float new_ori_head_confidence)
2779 {
2780  data->ori_head_confidence = new_ori_head_confidence;
2781  data_changed = true;
2782 }
2783 
2784 /** Get ori_neck value.
2785  * Neck position vector.
2786  * @return ori_neck value
2787  */
2788 float *
2790 {
2791  return data->ori_neck;
2792 }
2793 
2794 /** Get ori_neck value at given index.
2795  * Neck position vector.
2796  * @param index index of value
2797  * @return ori_neck value
2798  * @exception Exception thrown if index is out of bounds
2799  */
2800 float
2801 HumanSkeletonInterface::ori_neck(unsigned int index) const
2802 {
2803  if (index > 8) {
2804  throw Exception("Index value %u out of bounds (0..8)", index);
2805  }
2806  return data->ori_neck[index];
2808 
2809 /** Get maximum length of ori_neck value.
2810  * @return length of ori_neck value, can be length of the array or number of
2811  * maximum number of characters for a string
2812  */
2813 size_t
2815 {
2816  return 9;
2817 }
2818 
2819 /** Set ori_neck value.
2820  * Neck position vector.
2821  * @param new_ori_neck new ori_neck value
2822  */
2823 void
2824 HumanSkeletonInterface::set_ori_neck(const float * new_ori_neck)
2825 {
2826  memcpy(data->ori_neck, new_ori_neck, sizeof(float) * 9);
2827  data_changed = true;
2828 }
2829 
2830 /** Set ori_neck value at given index.
2831  * Neck position vector.
2832  * @param new_ori_neck new ori_neck value
2833  * @param index index for of the value
2834  */
2835 void
2836 HumanSkeletonInterface::set_ori_neck(unsigned int index, const float new_ori_neck)
2837 {
2838  if (index > 8) {
2839  throw Exception("Index value %u out of bounds (0..8)", index);
2840  }
2841  data->ori_neck[index] = new_ori_neck;
2843 }
2844 /** Get ori_neck_confidence value.
2845  *
2846  Neck position confidence.
2847  * @return ori_neck_confidence value
2848  */
2849 float
2851 {
2852  return data->ori_neck_confidence;
2853 }
2854 
2855 /** Get maximum length of ori_neck_confidence value.
2856  * @return length of ori_neck_confidence value, can be length of the array or number of
2857  * maximum number of characters for a string
2858  */
2859 size_t
2861 {
2862  return 1;
2863 }
2864 
2865 /** Set ori_neck_confidence value.
2866  *
2867  Neck position confidence.
2868  * @param new_ori_neck_confidence new ori_neck_confidence value
2869  */
2870 void
2871 HumanSkeletonInterface::set_ori_neck_confidence(const float new_ori_neck_confidence)
2872 {
2873  data->ori_neck_confidence = new_ori_neck_confidence;
2874  data_changed = true;
2875 }
2876 
2877 /** Get ori_torso value.
2878  * Torso position vector.
2879  * @return ori_torso value
2880  */
2881 float *
2883 {
2884  return data->ori_torso;
2885 }
2886 
2887 /** Get ori_torso value at given index.
2888  * Torso position vector.
2889  * @param index index of value
2890  * @return ori_torso value
2891  * @exception Exception thrown if index is out of bounds
2892  */
2893 float
2894 HumanSkeletonInterface::ori_torso(unsigned int index) const
2895 {
2896  if (index > 8) {
2897  throw Exception("Index value %u out of bounds (0..8)", index);
2898  }
2899  return data->ori_torso[index];
2901 
2902 /** Get maximum length of ori_torso value.
2903  * @return length of ori_torso value, can be length of the array or number of
2904  * maximum number of characters for a string
2905  */
2906 size_t
2908 {
2909  return 9;
2910 }
2911 
2912 /** Set ori_torso value.
2913  * Torso position vector.
2914  * @param new_ori_torso new ori_torso value
2915  */
2916 void
2917 HumanSkeletonInterface::set_ori_torso(const float * new_ori_torso)
2918 {
2919  memcpy(data->ori_torso, new_ori_torso, sizeof(float) * 9);
2920  data_changed = true;
2921 }
2922 
2923 /** Set ori_torso value at given index.
2924  * Torso position vector.
2925  * @param new_ori_torso new ori_torso value
2926  * @param index index for of the value
2927  */
2928 void
2929 HumanSkeletonInterface::set_ori_torso(unsigned int index, const float new_ori_torso)
2930 {
2931  if (index > 8) {
2932  throw Exception("Index value %u out of bounds (0..8)", index);
2933  }
2934  data->ori_torso[index] = new_ori_torso;
2936 }
2937 /** Get ori_torso_confidence value.
2938  *
2939  Torso position confidence.
2940  * @return ori_torso_confidence value
2941  */
2942 float
2944 {
2945  return data->ori_torso_confidence;
2946 }
2947 
2948 /** Get maximum length of ori_torso_confidence value.
2949  * @return length of ori_torso_confidence value, can be length of the array or number of
2950  * maximum number of characters for a string
2951  */
2952 size_t
2954 {
2955  return 1;
2956 }
2957 
2958 /** Set ori_torso_confidence value.
2959  *
2960  Torso position confidence.
2961  * @param new_ori_torso_confidence new ori_torso_confidence value
2962  */
2963 void
2964 HumanSkeletonInterface::set_ori_torso_confidence(const float new_ori_torso_confidence)
2965 {
2966  data->ori_torso_confidence = new_ori_torso_confidence;
2967  data_changed = true;
2968 }
2969 
2970 /** Get ori_waist value.
2971  * Waist position vector.
2972  * @return ori_waist value
2973  */
2974 float *
2976 {
2977  return data->ori_waist;
2978 }
2979 
2980 /** Get ori_waist value at given index.
2981  * Waist position vector.
2982  * @param index index of value
2983  * @return ori_waist value
2984  * @exception Exception thrown if index is out of bounds
2985  */
2986 float
2987 HumanSkeletonInterface::ori_waist(unsigned int index) const
2988 {
2989  if (index > 8) {
2990  throw Exception("Index value %u out of bounds (0..8)", index);
2991  }
2992  return data->ori_waist[index];
2994 
2995 /** Get maximum length of ori_waist value.
2996  * @return length of ori_waist value, can be length of the array or number of
2997  * maximum number of characters for a string
2998  */
2999 size_t
3001 {
3002  return 9;
3003 }
3004 
3005 /** Set ori_waist value.
3006  * Waist position vector.
3007  * @param new_ori_waist new ori_waist value
3008  */
3009 void
3010 HumanSkeletonInterface::set_ori_waist(const float * new_ori_waist)
3011 {
3012  memcpy(data->ori_waist, new_ori_waist, sizeof(float) * 9);
3013  data_changed = true;
3014 }
3015 
3016 /** Set ori_waist value at given index.
3017  * Waist position vector.
3018  * @param new_ori_waist new ori_waist value
3019  * @param index index for of the value
3020  */
3021 void
3022 HumanSkeletonInterface::set_ori_waist(unsigned int index, const float new_ori_waist)
3023 {
3024  if (index > 8) {
3025  throw Exception("Index value %u out of bounds (0..8)", index);
3026  }
3027  data->ori_waist[index] = new_ori_waist;
3029 }
3030 /** Get ori_waist_confidence value.
3031  *
3032  Waist position confidence.
3033  * @return ori_waist_confidence value
3034  */
3035 float
3037 {
3038  return data->ori_waist_confidence;
3039 }
3040 
3041 /** Get maximum length of ori_waist_confidence value.
3042  * @return length of ori_waist_confidence value, can be length of the array or number of
3043  * maximum number of characters for a string
3044  */
3045 size_t
3047 {
3048  return 1;
3049 }
3050 
3051 /** Set ori_waist_confidence value.
3052  *
3053  Waist position confidence.
3054  * @param new_ori_waist_confidence new ori_waist_confidence value
3055  */
3056 void
3057 HumanSkeletonInterface::set_ori_waist_confidence(const float new_ori_waist_confidence)
3058 {
3059  data->ori_waist_confidence = new_ori_waist_confidence;
3060  data_changed = true;
3061 }
3062 
3063 /** Get ori_left_collar value.
3064  *
3065  Left position vector.
3066  * @return ori_left_collar value
3067  */
3068 float *
3070 {
3071  return data->ori_left_collar;
3072 }
3073 
3074 /** Get ori_left_collar value at given index.
3075  *
3076  Left position vector.
3077  * @param index index of value
3078  * @return ori_left_collar value
3079  * @exception Exception thrown if index is out of bounds
3080  */
3081 float
3082 HumanSkeletonInterface::ori_left_collar(unsigned int index) const
3083 {
3084  if (index > 8) {
3085  throw Exception("Index value %u out of bounds (0..8)", index);
3086  }
3087  return data->ori_left_collar[index];
3089 
3090 /** Get maximum length of ori_left_collar value.
3091  * @return length of ori_left_collar value, can be length of the array or number of
3092  * maximum number of characters for a string
3093  */
3094 size_t
3096 {
3097  return 9;
3098 }
3099 
3100 /** Set ori_left_collar value.
3101  *
3102  Left position vector.
3103  * @param new_ori_left_collar new ori_left_collar value
3104  */
3105 void
3106 HumanSkeletonInterface::set_ori_left_collar(const float * new_ori_left_collar)
3107 {
3108  memcpy(data->ori_left_collar, new_ori_left_collar, sizeof(float) * 9);
3109  data_changed = true;
3110 }
3111 
3112 /** Set ori_left_collar value at given index.
3113  *
3114  Left position vector.
3115  * @param new_ori_left_collar new ori_left_collar value
3116  * @param index index for of the value
3117  */
3118 void
3119 HumanSkeletonInterface::set_ori_left_collar(unsigned int index, const float new_ori_left_collar)
3120 {
3121  if (index > 8) {
3122  throw Exception("Index value %u out of bounds (0..8)", index);
3123  }
3124  data->ori_left_collar[index] = new_ori_left_collar;
3126 }
3127 /** Get ori_left_collar_confidence value.
3128  *
3129  Left position confidence.
3130  * @return ori_left_collar_confidence value
3131  */
3132 float
3134 {
3135  return data->ori_left_collar_confidence;
3136 }
3137 
3138 /** Get maximum length of ori_left_collar_confidence value.
3139  * @return length of ori_left_collar_confidence value, can be length of the array or number of
3140  * maximum number of characters for a string
3141  */
3142 size_t
3144 {
3145  return 1;
3146 }
3147 
3148 /** Set ori_left_collar_confidence value.
3149  *
3150  Left position confidence.
3151  * @param new_ori_left_collar_confidence new ori_left_collar_confidence value
3152  */
3153 void
3154 HumanSkeletonInterface::set_ori_left_collar_confidence(const float new_ori_left_collar_confidence)
3155 {
3156  data->ori_left_collar_confidence = new_ori_left_collar_confidence;
3157  data_changed = true;
3158 }
3159 
3160 /** Get ori_left_shoulder value.
3161  *
3162  Left shoulder position vector.
3163  * @return ori_left_shoulder value
3164  */
3165 float *
3167 {
3168  return data->ori_left_shoulder;
3169 }
3170 
3171 /** Get ori_left_shoulder value at given index.
3172  *
3173  Left shoulder position vector.
3174  * @param index index of value
3175  * @return ori_left_shoulder value
3176  * @exception Exception thrown if index is out of bounds
3177  */
3178 float
3179 HumanSkeletonInterface::ori_left_shoulder(unsigned int index) const
3180 {
3181  if (index > 8) {
3182  throw Exception("Index value %u out of bounds (0..8)", index);
3183  }
3184  return data->ori_left_shoulder[index];
3186 
3187 /** Get maximum length of ori_left_shoulder value.
3188  * @return length of ori_left_shoulder value, can be length of the array or number of
3189  * maximum number of characters for a string
3190  */
3191 size_t
3193 {
3194  return 9;
3195 }
3196 
3197 /** Set ori_left_shoulder value.
3198  *
3199  Left shoulder position vector.
3200  * @param new_ori_left_shoulder new ori_left_shoulder value
3201  */
3202 void
3203 HumanSkeletonInterface::set_ori_left_shoulder(const float * new_ori_left_shoulder)
3204 {
3205  memcpy(data->ori_left_shoulder, new_ori_left_shoulder, sizeof(float) * 9);
3206  data_changed = true;
3207 }
3208 
3209 /** Set ori_left_shoulder value at given index.
3210  *
3211  Left shoulder position vector.
3212  * @param new_ori_left_shoulder new ori_left_shoulder value
3213  * @param index index for of the value
3214  */
3215 void
3216 HumanSkeletonInterface::set_ori_left_shoulder(unsigned int index, const float new_ori_left_shoulder)
3217 {
3218  if (index > 8) {
3219  throw Exception("Index value %u out of bounds (0..8)", index);
3220  }
3221  data->ori_left_shoulder[index] = new_ori_left_shoulder;
3223 }
3224 /** Get ori_left_shoulder_confidence value.
3225  *
3226  Left shoulder position confidence.
3227  * @return ori_left_shoulder_confidence value
3228  */
3229 float
3231 {
3232  return data->ori_left_shoulder_confidence;
3233 }
3234 
3235 /** Get maximum length of ori_left_shoulder_confidence value.
3236  * @return length of ori_left_shoulder_confidence value, can be length of the array or number of
3237  * maximum number of characters for a string
3238  */
3239 size_t
3241 {
3242  return 1;
3243 }
3244 
3245 /** Set ori_left_shoulder_confidence value.
3246  *
3247  Left shoulder position confidence.
3248  * @param new_ori_left_shoulder_confidence new ori_left_shoulder_confidence value
3249  */
3250 void
3251 HumanSkeletonInterface::set_ori_left_shoulder_confidence(const float new_ori_left_shoulder_confidence)
3252 {
3253  data->ori_left_shoulder_confidence = new_ori_left_shoulder_confidence;
3254  data_changed = true;
3255 }
3256 
3257 /** Get ori_left_elbow value.
3258  *
3259  Left elbow position vector.
3260  * @return ori_left_elbow value
3261  */
3262 float *
3264 {
3265  return data->ori_left_elbow;
3266 }
3267 
3268 /** Get ori_left_elbow value at given index.
3269  *
3270  Left elbow position vector.
3271  * @param index index of value
3272  * @return ori_left_elbow value
3273  * @exception Exception thrown if index is out of bounds
3274  */
3275 float
3276 HumanSkeletonInterface::ori_left_elbow(unsigned int index) const
3277 {
3278  if (index > 8) {
3279  throw Exception("Index value %u out of bounds (0..8)", index);
3280  }
3281  return data->ori_left_elbow[index];
3283 
3284 /** Get maximum length of ori_left_elbow value.
3285  * @return length of ori_left_elbow value, can be length of the array or number of
3286  * maximum number of characters for a string
3287  */
3288 size_t
3290 {
3291  return 9;
3292 }
3293 
3294 /** Set ori_left_elbow value.
3295  *
3296  Left elbow position vector.
3297  * @param new_ori_left_elbow new ori_left_elbow value
3298  */
3299 void
3300 HumanSkeletonInterface::set_ori_left_elbow(const float * new_ori_left_elbow)
3301 {
3302  memcpy(data->ori_left_elbow, new_ori_left_elbow, sizeof(float) * 9);
3303  data_changed = true;
3304 }
3305 
3306 /** Set ori_left_elbow value at given index.
3307  *
3308  Left elbow position vector.
3309  * @param new_ori_left_elbow new ori_left_elbow value
3310  * @param index index for of the value
3311  */
3312 void
3313 HumanSkeletonInterface::set_ori_left_elbow(unsigned int index, const float new_ori_left_elbow)
3314 {
3315  if (index > 8) {
3316  throw Exception("Index value %u out of bounds (0..8)", index);
3317  }
3318  data->ori_left_elbow[index] = new_ori_left_elbow;
3320 }
3321 /** Get ori_left_elbow_confidence value.
3322  *
3323  Left elbow position confidence.
3324  * @return ori_left_elbow_confidence value
3325  */
3326 float
3328 {
3329  return data->ori_left_elbow_confidence;
3330 }
3331 
3332 /** Get maximum length of ori_left_elbow_confidence value.
3333  * @return length of ori_left_elbow_confidence value, can be length of the array or number of
3334  * maximum number of characters for a string
3335  */
3336 size_t
3338 {
3339  return 1;
3340 }
3341 
3342 /** Set ori_left_elbow_confidence value.
3343  *
3344  Left elbow position confidence.
3345  * @param new_ori_left_elbow_confidence new ori_left_elbow_confidence value
3346  */
3347 void
3348 HumanSkeletonInterface::set_ori_left_elbow_confidence(const float new_ori_left_elbow_confidence)
3349 {
3350  data->ori_left_elbow_confidence = new_ori_left_elbow_confidence;
3351  data_changed = true;
3352 }
3353 
3354 /** Get ori_left_wrist value.
3355  *
3356  Left wrist position vector.
3357  * @return ori_left_wrist value
3358  */
3359 float *
3361 {
3362  return data->ori_left_wrist;
3363 }
3364 
3365 /** Get ori_left_wrist value at given index.
3366  *
3367  Left wrist position vector.
3368  * @param index index of value
3369  * @return ori_left_wrist value
3370  * @exception Exception thrown if index is out of bounds
3371  */
3372 float
3373 HumanSkeletonInterface::ori_left_wrist(unsigned int index) const
3374 {
3375  if (index > 8) {
3376  throw Exception("Index value %u out of bounds (0..8)", index);
3377  }
3378  return data->ori_left_wrist[index];
3380 
3381 /** Get maximum length of ori_left_wrist value.
3382  * @return length of ori_left_wrist value, can be length of the array or number of
3383  * maximum number of characters for a string
3384  */
3385 size_t
3387 {
3388  return 9;
3389 }
3390 
3391 /** Set ori_left_wrist value.
3392  *
3393  Left wrist position vector.
3394  * @param new_ori_left_wrist new ori_left_wrist value
3395  */
3396 void
3397 HumanSkeletonInterface::set_ori_left_wrist(const float * new_ori_left_wrist)
3398 {
3399  memcpy(data->ori_left_wrist, new_ori_left_wrist, sizeof(float) * 9);
3400  data_changed = true;
3401 }
3402 
3403 /** Set ori_left_wrist value at given index.
3404  *
3405  Left wrist position vector.
3406  * @param new_ori_left_wrist new ori_left_wrist value
3407  * @param index index for of the value
3408  */
3409 void
3410 HumanSkeletonInterface::set_ori_left_wrist(unsigned int index, const float new_ori_left_wrist)
3411 {
3412  if (index > 8) {
3413  throw Exception("Index value %u out of bounds (0..8)", index);
3414  }
3415  data->ori_left_wrist[index] = new_ori_left_wrist;
3417 }
3418 /** Get ori_left_wrist_confidence value.
3419  *
3420  Left wrist position confidence.
3421  * @return ori_left_wrist_confidence value
3422  */
3423 float
3425 {
3426  return data->ori_left_wrist_confidence;
3427 }
3428 
3429 /** Get maximum length of ori_left_wrist_confidence value.
3430  * @return length of ori_left_wrist_confidence value, can be length of the array or number of
3431  * maximum number of characters for a string
3432  */
3433 size_t
3435 {
3436  return 1;
3437 }
3438 
3439 /** Set ori_left_wrist_confidence value.
3440  *
3441  Left wrist position confidence.
3442  * @param new_ori_left_wrist_confidence new ori_left_wrist_confidence value
3443  */
3444 void
3445 HumanSkeletonInterface::set_ori_left_wrist_confidence(const float new_ori_left_wrist_confidence)
3446 {
3447  data->ori_left_wrist_confidence = new_ori_left_wrist_confidence;
3448  data_changed = true;
3449 }
3450 
3451 /** Get ori_left_hand value.
3452  *
3453  Left hand position vector.
3454  * @return ori_left_hand value
3455  */
3456 float *
3458 {
3459  return data->ori_left_hand;
3460 }
3461 
3462 /** Get ori_left_hand value at given index.
3463  *
3464  Left hand position vector.
3465  * @param index index of value
3466  * @return ori_left_hand value
3467  * @exception Exception thrown if index is out of bounds
3468  */
3469 float
3470 HumanSkeletonInterface::ori_left_hand(unsigned int index) const
3471 {
3472  if (index > 8) {
3473  throw Exception("Index value %u out of bounds (0..8)", index);
3474  }
3475  return data->ori_left_hand[index];
3477 
3478 /** Get maximum length of ori_left_hand value.
3479  * @return length of ori_left_hand value, can be length of the array or number of
3480  * maximum number of characters for a string
3481  */
3482 size_t
3484 {
3485  return 9;
3486 }
3487 
3488 /** Set ori_left_hand value.
3489  *
3490  Left hand position vector.
3491  * @param new_ori_left_hand new ori_left_hand value
3492  */
3493 void
3494 HumanSkeletonInterface::set_ori_left_hand(const float * new_ori_left_hand)
3495 {
3496  memcpy(data->ori_left_hand, new_ori_left_hand, sizeof(float) * 9);
3497  data_changed = true;
3498 }
3499 
3500 /** Set ori_left_hand value at given index.
3501  *
3502  Left hand position vector.
3503  * @param new_ori_left_hand new ori_left_hand value
3504  * @param index index for of the value
3505  */
3506 void
3507 HumanSkeletonInterface::set_ori_left_hand(unsigned int index, const float new_ori_left_hand)
3508 {
3509  if (index > 8) {
3510  throw Exception("Index value %u out of bounds (0..8)", index);
3511  }
3512  data->ori_left_hand[index] = new_ori_left_hand;
3514 }
3515 /** Get ori_left_hand_confidence value.
3516  *
3517  Left hand position confidence.
3518  * @return ori_left_hand_confidence value
3519  */
3520 float
3522 {
3523  return data->ori_left_hand_confidence;
3524 }
3525 
3526 /** Get maximum length of ori_left_hand_confidence value.
3527  * @return length of ori_left_hand_confidence value, can be length of the array or number of
3528  * maximum number of characters for a string
3529  */
3530 size_t
3532 {
3533  return 1;
3534 }
3535 
3536 /** Set ori_left_hand_confidence value.
3537  *
3538  Left hand position confidence.
3539  * @param new_ori_left_hand_confidence new ori_left_hand_confidence value
3540  */
3541 void
3542 HumanSkeletonInterface::set_ori_left_hand_confidence(const float new_ori_left_hand_confidence)
3543 {
3544  data->ori_left_hand_confidence = new_ori_left_hand_confidence;
3545  data_changed = true;
3546 }
3547 
3548 /** Get ori_left_fingertip value.
3549  *
3550  Left fingertip position vector.
3551  * @return ori_left_fingertip value
3552  */
3553 float *
3555 {
3556  return data->ori_left_fingertip;
3557 }
3558 
3559 /** Get ori_left_fingertip value at given index.
3560  *
3561  Left fingertip position vector.
3562  * @param index index of value
3563  * @return ori_left_fingertip value
3564  * @exception Exception thrown if index is out of bounds
3565  */
3566 float
3567 HumanSkeletonInterface::ori_left_fingertip(unsigned int index) const
3568 {
3569  if (index > 8) {
3570  throw Exception("Index value %u out of bounds (0..8)", index);
3571  }
3572  return data->ori_left_fingertip[index];
3574 
3575 /** Get maximum length of ori_left_fingertip value.
3576  * @return length of ori_left_fingertip value, can be length of the array or number of
3577  * maximum number of characters for a string
3578  */
3579 size_t
3581 {
3582  return 9;
3583 }
3584 
3585 /** Set ori_left_fingertip value.
3586  *
3587  Left fingertip position vector.
3588  * @param new_ori_left_fingertip new ori_left_fingertip value
3589  */
3590 void
3591 HumanSkeletonInterface::set_ori_left_fingertip(const float * new_ori_left_fingertip)
3592 {
3593  memcpy(data->ori_left_fingertip, new_ori_left_fingertip, sizeof(float) * 9);
3594  data_changed = true;
3595 }
3596 
3597 /** Set ori_left_fingertip value at given index.
3598  *
3599  Left fingertip position vector.
3600  * @param new_ori_left_fingertip new ori_left_fingertip value
3601  * @param index index for of the value
3602  */
3603 void
3604 HumanSkeletonInterface::set_ori_left_fingertip(unsigned int index, const float new_ori_left_fingertip)
3605 {
3606  if (index > 8) {
3607  throw Exception("Index value %u out of bounds (0..8)", index);
3608  }
3609  data->ori_left_fingertip[index] = new_ori_left_fingertip;
3611 }
3612 /** Get ori_left_fingertip_confidence value.
3613  *
3614  Left fingertip position confidence.
3615  * @return ori_left_fingertip_confidence value
3616  */
3617 float
3619 {
3620  return data->ori_left_fingertip_confidence;
3621 }
3622 
3623 /** Get maximum length of ori_left_fingertip_confidence value.
3624  * @return length of ori_left_fingertip_confidence value, can be length of the array or number of
3625  * maximum number of characters for a string
3626  */
3627 size_t
3629 {
3630  return 1;
3631 }
3632 
3633 /** Set ori_left_fingertip_confidence value.
3634  *
3635  Left fingertip position confidence.
3636  * @param new_ori_left_fingertip_confidence new ori_left_fingertip_confidence value
3637  */
3638 void
3639 HumanSkeletonInterface::set_ori_left_fingertip_confidence(const float new_ori_left_fingertip_confidence)
3640 {
3641  data->ori_left_fingertip_confidence = new_ori_left_fingertip_confidence;
3642  data_changed = true;
3643 }
3644 
3645 /** Get ori_right_collar value.
3646  *
3647  Right collar position vector.
3648  * @return ori_right_collar value
3649  */
3650 float *
3652 {
3653  return data->ori_right_collar;
3654 }
3655 
3656 /** Get ori_right_collar value at given index.
3657  *
3658  Right collar position vector.
3659  * @param index index of value
3660  * @return ori_right_collar value
3661  * @exception Exception thrown if index is out of bounds
3662  */
3663 float
3664 HumanSkeletonInterface::ori_right_collar(unsigned int index) const
3665 {
3666  if (index > 8) {
3667  throw Exception("Index value %u out of bounds (0..8)", index);
3668  }
3669  return data->ori_right_collar[index];
3671 
3672 /** Get maximum length of ori_right_collar value.
3673  * @return length of ori_right_collar value, can be length of the array or number of
3674  * maximum number of characters for a string
3675  */
3676 size_t
3678 {
3679  return 9;
3680 }
3681 
3682 /** Set ori_right_collar value.
3683  *
3684  Right collar position vector.
3685  * @param new_ori_right_collar new ori_right_collar value
3686  */
3687 void
3688 HumanSkeletonInterface::set_ori_right_collar(const float * new_ori_right_collar)
3689 {
3690  memcpy(data->ori_right_collar, new_ori_right_collar, sizeof(float) * 9);
3691  data_changed = true;
3692 }
3693 
3694 /** Set ori_right_collar value at given index.
3695  *
3696  Right collar position vector.
3697  * @param new_ori_right_collar new ori_right_collar value
3698  * @param index index for of the value
3699  */
3700 void
3701 HumanSkeletonInterface::set_ori_right_collar(unsigned int index, const float new_ori_right_collar)
3702 {
3703  if (index > 8) {
3704  throw Exception("Index value %u out of bounds (0..8)", index);
3705  }
3706  data->ori_right_collar[index] = new_ori_right_collar;
3708 }
3709 /** Get ori_right_collar_confidence value.
3710  *
3711  Right collar position confidence.
3712  * @return ori_right_collar_confidence value
3713  */
3714 float
3716 {
3717  return data->ori_right_collar_confidence;
3718 }
3719 
3720 /** Get maximum length of ori_right_collar_confidence value.
3721  * @return length of ori_right_collar_confidence value, can be length of the array or number of
3722  * maximum number of characters for a string
3723  */
3724 size_t
3726 {
3727  return 1;
3728 }
3729 
3730 /** Set ori_right_collar_confidence value.
3731  *
3732  Right collar position confidence.
3733  * @param new_ori_right_collar_confidence new ori_right_collar_confidence value
3734  */
3735 void
3736 HumanSkeletonInterface::set_ori_right_collar_confidence(const float new_ori_right_collar_confidence)
3737 {
3738  data->ori_right_collar_confidence = new_ori_right_collar_confidence;
3739  data_changed = true;
3740 }
3741 
3742 /** Get ori_right_shoulder value.
3743  *
3744  Right shoulder position vector.
3745  * @return ori_right_shoulder value
3746  */
3747 float *
3749 {
3750  return data->ori_right_shoulder;
3751 }
3752 
3753 /** Get ori_right_shoulder value at given index.
3754  *
3755  Right shoulder position vector.
3756  * @param index index of value
3757  * @return ori_right_shoulder value
3758  * @exception Exception thrown if index is out of bounds
3759  */
3760 float
3761 HumanSkeletonInterface::ori_right_shoulder(unsigned int index) const
3762 {
3763  if (index > 8) {
3764  throw Exception("Index value %u out of bounds (0..8)", index);
3765  }
3766  return data->ori_right_shoulder[index];
3768 
3769 /** Get maximum length of ori_right_shoulder value.
3770  * @return length of ori_right_shoulder value, can be length of the array or number of
3771  * maximum number of characters for a string
3772  */
3773 size_t
3775 {
3776  return 9;
3777 }
3778 
3779 /** Set ori_right_shoulder value.
3780  *
3781  Right shoulder position vector.
3782  * @param new_ori_right_shoulder new ori_right_shoulder value
3783  */
3784 void
3785 HumanSkeletonInterface::set_ori_right_shoulder(const float * new_ori_right_shoulder)
3786 {
3787  memcpy(data->ori_right_shoulder, new_ori_right_shoulder, sizeof(float) * 9);
3788  data_changed = true;
3789 }
3790 
3791 /** Set ori_right_shoulder value at given index.
3792  *
3793  Right shoulder position vector.
3794  * @param new_ori_right_shoulder new ori_right_shoulder value
3795  * @param index index for of the value
3796  */
3797 void
3798 HumanSkeletonInterface::set_ori_right_shoulder(unsigned int index, const float new_ori_right_shoulder)
3799 {
3800  if (index > 8) {
3801  throw Exception("Index value %u out of bounds (0..8)", index);
3802  }
3803  data->ori_right_shoulder[index] = new_ori_right_shoulder;
3805 }
3806 /** Get ori_right_shoulder_confidence value.
3807  *
3808  Right shoulder position confidence.
3809  * @return ori_right_shoulder_confidence value
3810  */
3811 float
3813 {
3814  return data->ori_right_shoulder_confidence;
3815 }
3816 
3817 /** Get maximum length of ori_right_shoulder_confidence value.
3818  * @return length of ori_right_shoulder_confidence value, can be length of the array or number of
3819  * maximum number of characters for a string
3820  */
3821 size_t
3823 {
3824  return 1;
3825 }
3826 
3827 /** Set ori_right_shoulder_confidence value.
3828  *
3829  Right shoulder position confidence.
3830  * @param new_ori_right_shoulder_confidence new ori_right_shoulder_confidence value
3831  */
3832 void
3833 HumanSkeletonInterface::set_ori_right_shoulder_confidence(const float new_ori_right_shoulder_confidence)
3834 {
3835  data->ori_right_shoulder_confidence = new_ori_right_shoulder_confidence;
3836  data_changed = true;
3837 }
3838 
3839 /** Get ori_right_elbow value.
3840  *
3841  Right elbow position vector.
3842  * @return ori_right_elbow value
3843  */
3844 float *
3846 {
3847  return data->ori_right_elbow;
3848 }
3849 
3850 /** Get ori_right_elbow value at given index.
3851  *
3852  Right elbow position vector.
3853  * @param index index of value
3854  * @return ori_right_elbow value
3855  * @exception Exception thrown if index is out of bounds
3856  */
3857 float
3858 HumanSkeletonInterface::ori_right_elbow(unsigned int index) const
3859 {
3860  if (index > 8) {
3861  throw Exception("Index value %u out of bounds (0..8)", index);
3862  }
3863  return data->ori_right_elbow[index];
3865 
3866 /** Get maximum length of ori_right_elbow value.
3867  * @return length of ori_right_elbow value, can be length of the array or number of
3868  * maximum number of characters for a string
3869  */
3870 size_t
3872 {
3873  return 9;
3874 }
3875 
3876 /** Set ori_right_elbow value.
3877  *
3878  Right elbow position vector.
3879  * @param new_ori_right_elbow new ori_right_elbow value
3880  */
3881 void
3882 HumanSkeletonInterface::set_ori_right_elbow(const float * new_ori_right_elbow)
3883 {
3884  memcpy(data->ori_right_elbow, new_ori_right_elbow, sizeof(float) * 9);
3885  data_changed = true;
3886 }
3887 
3888 /** Set ori_right_elbow value at given index.
3889  *
3890  Right elbow position vector.
3891  * @param new_ori_right_elbow new ori_right_elbow value
3892  * @param index index for of the value
3893  */
3894 void
3895 HumanSkeletonInterface::set_ori_right_elbow(unsigned int index, const float new_ori_right_elbow)
3896 {
3897  if (index > 8) {
3898  throw Exception("Index value %u out of bounds (0..8)", index);
3899  }
3900  data->ori_right_elbow[index] = new_ori_right_elbow;
3902 }
3903 /** Get ori_right_elbow_confidence value.
3904  *
3905  Right elbow position confidence.
3906  * @return ori_right_elbow_confidence value
3907  */
3908 float
3910 {
3911  return data->ori_right_elbow_confidence;
3912 }
3913 
3914 /** Get maximum length of ori_right_elbow_confidence value.
3915  * @return length of ori_right_elbow_confidence value, can be length of the array or number of
3916  * maximum number of characters for a string
3917  */
3918 size_t
3920 {
3921  return 1;
3922 }
3923 
3924 /** Set ori_right_elbow_confidence value.
3925  *
3926  Right elbow position confidence.
3927  * @param new_ori_right_elbow_confidence new ori_right_elbow_confidence value
3928  */
3929 void
3930 HumanSkeletonInterface::set_ori_right_elbow_confidence(const float new_ori_right_elbow_confidence)
3931 {
3932  data->ori_right_elbow_confidence = new_ori_right_elbow_confidence;
3933  data_changed = true;
3934 }
3935 
3936 /** Get ori_right_wrist value.
3937  *
3938  Right wrist position vector.
3939  * @return ori_right_wrist value
3940  */
3941 float *
3943 {
3944  return data->ori_right_wrist;
3945 }
3946 
3947 /** Get ori_right_wrist value at given index.
3948  *
3949  Right wrist position vector.
3950  * @param index index of value
3951  * @return ori_right_wrist value
3952  * @exception Exception thrown if index is out of bounds
3953  */
3954 float
3955 HumanSkeletonInterface::ori_right_wrist(unsigned int index) const
3956 {
3957  if (index > 8) {
3958  throw Exception("Index value %u out of bounds (0..8)", index);
3959  }
3960  return data->ori_right_wrist[index];
3962 
3963 /** Get maximum length of ori_right_wrist value.
3964  * @return length of ori_right_wrist value, can be length of the array or number of
3965  * maximum number of characters for a string
3966  */
3967 size_t
3969 {
3970  return 9;
3971 }
3972 
3973 /** Set ori_right_wrist value.
3974  *
3975  Right wrist position vector.
3976  * @param new_ori_right_wrist new ori_right_wrist value
3977  */
3978 void
3979 HumanSkeletonInterface::set_ori_right_wrist(const float * new_ori_right_wrist)
3980 {
3981  memcpy(data->ori_right_wrist, new_ori_right_wrist, sizeof(float) * 9);
3982  data_changed = true;
3983 }
3984 
3985 /** Set ori_right_wrist value at given index.
3986  *
3987  Right wrist position vector.
3988  * @param new_ori_right_wrist new ori_right_wrist value
3989  * @param index index for of the value
3990  */
3991 void
3992 HumanSkeletonInterface::set_ori_right_wrist(unsigned int index, const float new_ori_right_wrist)
3993 {
3994  if (index > 8) {
3995  throw Exception("Index value %u out of bounds (0..8)", index);
3996  }
3997  data->ori_right_wrist[index] = new_ori_right_wrist;
3999 }
4000 /** Get ori_right_wrist_confidence value.
4001  *
4002  Right wrist position confidence.
4003  * @return ori_right_wrist_confidence value
4004  */
4005 float
4007 {
4008  return data->ori_right_wrist_confidence;
4009 }
4010 
4011 /** Get maximum length of ori_right_wrist_confidence value.
4012  * @return length of ori_right_wrist_confidence value, can be length of the array or number of
4013  * maximum number of characters for a string
4014  */
4015 size_t
4017 {
4018  return 1;
4019 }
4020 
4021 /** Set ori_right_wrist_confidence value.
4022  *
4023  Right wrist position confidence.
4024  * @param new_ori_right_wrist_confidence new ori_right_wrist_confidence value
4025  */
4026 void
4027 HumanSkeletonInterface::set_ori_right_wrist_confidence(const float new_ori_right_wrist_confidence)
4028 {
4029  data->ori_right_wrist_confidence = new_ori_right_wrist_confidence;
4030  data_changed = true;
4031 }
4032 
4033 /** Get ori_right_hand value.
4034  *
4035  Right hand position vector.
4036  * @return ori_right_hand value
4037  */
4038 float *
4040 {
4041  return data->ori_right_hand;
4042 }
4043 
4044 /** Get ori_right_hand value at given index.
4045  *
4046  Right hand position vector.
4047  * @param index index of value
4048  * @return ori_right_hand value
4049  * @exception Exception thrown if index is out of bounds
4050  */
4051 float
4052 HumanSkeletonInterface::ori_right_hand(unsigned int index) const
4053 {
4054  if (index > 8) {
4055  throw Exception("Index value %u out of bounds (0..8)", index);
4056  }
4057  return data->ori_right_hand[index];
4059 
4060 /** Get maximum length of ori_right_hand value.
4061  * @return length of ori_right_hand value, can be length of the array or number of
4062  * maximum number of characters for a string
4063  */
4064 size_t
4066 {
4067  return 9;
4068 }
4069 
4070 /** Set ori_right_hand value.
4071  *
4072  Right hand position vector.
4073  * @param new_ori_right_hand new ori_right_hand value
4074  */
4075 void
4076 HumanSkeletonInterface::set_ori_right_hand(const float * new_ori_right_hand)
4077 {
4078  memcpy(data->ori_right_hand, new_ori_right_hand, sizeof(float) * 9);
4079  data_changed = true;
4080 }
4081 
4082 /** Set ori_right_hand value at given index.
4083  *
4084  Right hand position vector.
4085  * @param new_ori_right_hand new ori_right_hand value
4086  * @param index index for of the value
4087  */
4088 void
4089 HumanSkeletonInterface::set_ori_right_hand(unsigned int index, const float new_ori_right_hand)
4090 {
4091  if (index > 8) {
4092  throw Exception("Index value %u out of bounds (0..8)", index);
4093  }
4094  data->ori_right_hand[index] = new_ori_right_hand;
4096 }
4097 /** Get ori_right_hand_confidence value.
4098  *
4099  Right hand position confidence.
4100  * @return ori_right_hand_confidence value
4101  */
4102 float
4104 {
4105  return data->ori_right_hand_confidence;
4106 }
4107 
4108 /** Get maximum length of ori_right_hand_confidence value.
4109  * @return length of ori_right_hand_confidence value, can be length of the array or number of
4110  * maximum number of characters for a string
4111  */
4112 size_t
4114 {
4115  return 1;
4116 }
4117 
4118 /** Set ori_right_hand_confidence value.
4119  *
4120  Right hand position confidence.
4121  * @param new_ori_right_hand_confidence new ori_right_hand_confidence value
4122  */
4123 void
4124 HumanSkeletonInterface::set_ori_right_hand_confidence(const float new_ori_right_hand_confidence)
4125 {
4126  data->ori_right_hand_confidence = new_ori_right_hand_confidence;
4127  data_changed = true;
4128 }
4129 
4130 /** Get ori_right_fingertip value.
4131  *
4132  Right fingertip position vector.
4133  * @return ori_right_fingertip value
4134  */
4135 float *
4137 {
4138  return data->ori_right_fingertip;
4139 }
4140 
4141 /** Get ori_right_fingertip value at given index.
4142  *
4143  Right fingertip position vector.
4144  * @param index index of value
4145  * @return ori_right_fingertip value
4146  * @exception Exception thrown if index is out of bounds
4147  */
4148 float
4149 HumanSkeletonInterface::ori_right_fingertip(unsigned int index) const
4150 {
4151  if (index > 8) {
4152  throw Exception("Index value %u out of bounds (0..8)", index);
4153  }
4154  return data->ori_right_fingertip[index];
4156 
4157 /** Get maximum length of ori_right_fingertip value.
4158  * @return length of ori_right_fingertip value, can be length of the array or number of
4159  * maximum number of characters for a string
4160  */
4161 size_t
4163 {
4164  return 9;
4165 }
4166 
4167 /** Set ori_right_fingertip value.
4168  *
4169  Right fingertip position vector.
4170  * @param new_ori_right_fingertip new ori_right_fingertip value
4171  */
4172 void
4173 HumanSkeletonInterface::set_ori_right_fingertip(const float * new_ori_right_fingertip)
4174 {
4175  memcpy(data->ori_right_fingertip, new_ori_right_fingertip, sizeof(float) * 9);
4176  data_changed = true;
4177 }
4178 
4179 /** Set ori_right_fingertip value at given index.
4180  *
4181  Right fingertip position vector.
4182  * @param new_ori_right_fingertip new ori_right_fingertip value
4183  * @param index index for of the value
4184  */
4185 void
4186 HumanSkeletonInterface::set_ori_right_fingertip(unsigned int index, const float new_ori_right_fingertip)
4187 {
4188  if (index > 8) {
4189  throw Exception("Index value %u out of bounds (0..8)", index);
4190  }
4191  data->ori_right_fingertip[index] = new_ori_right_fingertip;
4193 }
4194 /** Get ori_right_fingertip_confidence value.
4195  *
4196  Right fingertip position confidence.
4197  * @return ori_right_fingertip_confidence value
4198  */
4199 float
4201 {
4202  return data->ori_right_fingertip_confidence;
4203 }
4204 
4205 /** Get maximum length of ori_right_fingertip_confidence value.
4206  * @return length of ori_right_fingertip_confidence value, can be length of the array or number of
4207  * maximum number of characters for a string
4208  */
4209 size_t
4211 {
4212  return 1;
4213 }
4214 
4215 /** Set ori_right_fingertip_confidence value.
4216  *
4217  Right fingertip position confidence.
4218  * @param new_ori_right_fingertip_confidence new ori_right_fingertip_confidence value
4219  */
4220 void
4221 HumanSkeletonInterface::set_ori_right_fingertip_confidence(const float new_ori_right_fingertip_confidence)
4222 {
4223  data->ori_right_fingertip_confidence = new_ori_right_fingertip_confidence;
4224  data_changed = true;
4225 }
4226 
4227 /** Get ori_left_hip value.
4228  *
4229  Left hip position vector.
4230  * @return ori_left_hip value
4231  */
4232 float *
4234 {
4235  return data->ori_left_hip;
4236 }
4237 
4238 /** Get ori_left_hip value at given index.
4239  *
4240  Left hip position vector.
4241  * @param index index of value
4242  * @return ori_left_hip value
4243  * @exception Exception thrown if index is out of bounds
4244  */
4245 float
4246 HumanSkeletonInterface::ori_left_hip(unsigned int index) const
4247 {
4248  if (index > 8) {
4249  throw Exception("Index value %u out of bounds (0..8)", index);
4250  }
4251  return data->ori_left_hip[index];
4253 
4254 /** Get maximum length of ori_left_hip value.
4255  * @return length of ori_left_hip value, can be length of the array or number of
4256  * maximum number of characters for a string
4257  */
4258 size_t
4260 {
4261  return 9;
4262 }
4263 
4264 /** Set ori_left_hip value.
4265  *
4266  Left hip position vector.
4267  * @param new_ori_left_hip new ori_left_hip value
4268  */
4269 void
4270 HumanSkeletonInterface::set_ori_left_hip(const float * new_ori_left_hip)
4271 {
4272  memcpy(data->ori_left_hip, new_ori_left_hip, sizeof(float) * 9);
4273  data_changed = true;
4274 }
4275 
4276 /** Set ori_left_hip value at given index.
4277  *
4278  Left hip position vector.
4279  * @param new_ori_left_hip new ori_left_hip value
4280  * @param index index for of the value
4281  */
4282 void
4283 HumanSkeletonInterface::set_ori_left_hip(unsigned int index, const float new_ori_left_hip)
4284 {
4285  if (index > 8) {
4286  throw Exception("Index value %u out of bounds (0..8)", index);
4287  }
4288  data->ori_left_hip[index] = new_ori_left_hip;
4290 }
4291 /** Get ori_left_hip_confidence value.
4292  *
4293  Left hip position confidence.
4294  * @return ori_left_hip_confidence value
4295  */
4296 float
4298 {
4299  return data->ori_left_hip_confidence;
4300 }
4301 
4302 /** Get maximum length of ori_left_hip_confidence value.
4303  * @return length of ori_left_hip_confidence value, can be length of the array or number of
4304  * maximum number of characters for a string
4305  */
4306 size_t
4308 {
4309  return 1;
4310 }
4311 
4312 /** Set ori_left_hip_confidence value.
4313  *
4314  Left hip position confidence.
4315  * @param new_ori_left_hip_confidence new ori_left_hip_confidence value
4316  */
4317 void
4318 HumanSkeletonInterface::set_ori_left_hip_confidence(const float new_ori_left_hip_confidence)
4319 {
4320  data->ori_left_hip_confidence = new_ori_left_hip_confidence;
4321  data_changed = true;
4322 }
4323 
4324 /** Get ori_left_knee value.
4325  *
4326  Left knee position vector.
4327  * @return ori_left_knee value
4328  */
4329 float *
4331 {
4332  return data->ori_left_knee;
4333 }
4334 
4335 /** Get ori_left_knee value at given index.
4336  *
4337  Left knee position vector.
4338  * @param index index of value
4339  * @return ori_left_knee value
4340  * @exception Exception thrown if index is out of bounds
4341  */
4342 float
4343 HumanSkeletonInterface::ori_left_knee(unsigned int index) const
4344 {
4345  if (index > 8) {
4346  throw Exception("Index value %u out of bounds (0..8)", index);
4347  }
4348  return data->ori_left_knee[index];
4350 
4351 /** Get maximum length of ori_left_knee value.
4352  * @return length of ori_left_knee value, can be length of the array or number of
4353  * maximum number of characters for a string
4354  */
4355 size_t
4357 {
4358  return 9;
4359 }
4360 
4361 /** Set ori_left_knee value.
4362  *
4363  Left knee position vector.
4364  * @param new_ori_left_knee new ori_left_knee value
4365  */
4366 void
4367 HumanSkeletonInterface::set_ori_left_knee(const float * new_ori_left_knee)
4368 {
4369  memcpy(data->ori_left_knee, new_ori_left_knee, sizeof(float) * 9);
4370  data_changed = true;
4371 }
4372 
4373 /** Set ori_left_knee value at given index.
4374  *
4375  Left knee position vector.
4376  * @param new_ori_left_knee new ori_left_knee value
4377  * @param index index for of the value
4378  */
4379 void
4380 HumanSkeletonInterface::set_ori_left_knee(unsigned int index, const float new_ori_left_knee)
4381 {
4382  if (index > 8) {
4383  throw Exception("Index value %u out of bounds (0..8)", index);
4384  }
4385  data->ori_left_knee[index] = new_ori_left_knee;
4387 }
4388 /** Get ori_left_knee_confidence value.
4389  *
4390  Left knee position confidence.
4391  * @return ori_left_knee_confidence value
4392  */
4393 float
4395 {
4396  return data->ori_left_knee_confidence;
4397 }
4398 
4399 /** Get maximum length of ori_left_knee_confidence value.
4400  * @return length of ori_left_knee_confidence value, can be length of the array or number of
4401  * maximum number of characters for a string
4402  */
4403 size_t
4405 {
4406  return 1;
4407 }
4408 
4409 /** Set ori_left_knee_confidence value.
4410  *
4411  Left knee position confidence.
4412  * @param new_ori_left_knee_confidence new ori_left_knee_confidence value
4413  */
4414 void
4415 HumanSkeletonInterface::set_ori_left_knee_confidence(const float new_ori_left_knee_confidence)
4416 {
4417  data->ori_left_knee_confidence = new_ori_left_knee_confidence;
4418  data_changed = true;
4419 }
4420 
4421 /** Get ori_left_ankle value.
4422  *
4423  Left ankle position vector.
4424  * @return ori_left_ankle value
4425  */
4426 float *
4428 {
4429  return data->ori_left_ankle;
4430 }
4431 
4432 /** Get ori_left_ankle value at given index.
4433  *
4434  Left ankle position vector.
4435  * @param index index of value
4436  * @return ori_left_ankle value
4437  * @exception Exception thrown if index is out of bounds
4438  */
4439 float
4440 HumanSkeletonInterface::ori_left_ankle(unsigned int index) const
4441 {
4442  if (index > 8) {
4443  throw Exception("Index value %u out of bounds (0..8)", index);
4444  }
4445  return data->ori_left_ankle[index];
4447 
4448 /** Get maximum length of ori_left_ankle value.
4449  * @return length of ori_left_ankle value, can be length of the array or number of
4450  * maximum number of characters for a string
4451  */
4452 size_t
4454 {
4455  return 9;
4456 }
4457 
4458 /** Set ori_left_ankle value.
4459  *
4460  Left ankle position vector.
4461  * @param new_ori_left_ankle new ori_left_ankle value
4462  */
4463 void
4464 HumanSkeletonInterface::set_ori_left_ankle(const float * new_ori_left_ankle)
4465 {
4466  memcpy(data->ori_left_ankle, new_ori_left_ankle, sizeof(float) * 9);
4467  data_changed = true;
4468 }
4469 
4470 /** Set ori_left_ankle value at given index.
4471  *
4472  Left ankle position vector.
4473  * @param new_ori_left_ankle new ori_left_ankle value
4474  * @param index index for of the value
4475  */
4476 void
4477 HumanSkeletonInterface::set_ori_left_ankle(unsigned int index, const float new_ori_left_ankle)
4478 {
4479  if (index > 8) {
4480  throw Exception("Index value %u out of bounds (0..8)", index);
4481  }
4482  data->ori_left_ankle[index] = new_ori_left_ankle;
4484 }
4485 /** Get ori_left_ankle_confidence value.
4486  *
4487  Left ankle position confidence.
4488  * @return ori_left_ankle_confidence value
4489  */
4490 float
4492 {
4493  return data->ori_left_ankle_confidence;
4494 }
4495 
4496 /** Get maximum length of ori_left_ankle_confidence value.
4497  * @return length of ori_left_ankle_confidence value, can be length of the array or number of
4498  * maximum number of characters for a string
4499  */
4500 size_t
4502 {
4503  return 1;
4504 }
4505 
4506 /** Set ori_left_ankle_confidence value.
4507  *
4508  Left ankle position confidence.
4509  * @param new_ori_left_ankle_confidence new ori_left_ankle_confidence value
4510  */
4511 void
4512 HumanSkeletonInterface::set_ori_left_ankle_confidence(const float new_ori_left_ankle_confidence)
4513 {
4514  data->ori_left_ankle_confidence = new_ori_left_ankle_confidence;
4515  data_changed = true;
4516 }
4517 
4518 /** Get ori_left_foot value.
4519  *
4520  Left foot position vector.
4521  * @return ori_left_foot value
4522  */
4523 float *
4525 {
4526  return data->ori_left_foot;
4527 }
4528 
4529 /** Get ori_left_foot value at given index.
4530  *
4531  Left foot position vector.
4532  * @param index index of value
4533  * @return ori_left_foot value
4534  * @exception Exception thrown if index is out of bounds
4535  */
4536 float
4537 HumanSkeletonInterface::ori_left_foot(unsigned int index) const
4538 {
4539  if (index > 8) {
4540  throw Exception("Index value %u out of bounds (0..8)", index);
4541  }
4542  return data->ori_left_foot[index];
4544 
4545 /** Get maximum length of ori_left_foot value.
4546  * @return length of ori_left_foot value, can be length of the array or number of
4547  * maximum number of characters for a string
4548  */
4549 size_t
4551 {
4552  return 9;
4553 }
4554 
4555 /** Set ori_left_foot value.
4556  *
4557  Left foot position vector.
4558  * @param new_ori_left_foot new ori_left_foot value
4559  */
4560 void
4561 HumanSkeletonInterface::set_ori_left_foot(const float * new_ori_left_foot)
4562 {
4563  memcpy(data->ori_left_foot, new_ori_left_foot, sizeof(float) * 9);
4564  data_changed = true;
4565 }
4566 
4567 /** Set ori_left_foot value at given index.
4568  *
4569  Left foot position vector.
4570  * @param new_ori_left_foot new ori_left_foot value
4571  * @param index index for of the value
4572  */
4573 void
4574 HumanSkeletonInterface::set_ori_left_foot(unsigned int index, const float new_ori_left_foot)
4575 {
4576  if (index > 8) {
4577  throw Exception("Index value %u out of bounds (0..8)", index);
4578  }
4579  data->ori_left_foot[index] = new_ori_left_foot;
4581 }
4582 /** Get ori_left_foot_confidence value.
4583  *
4584  Left foot position confidence.
4585  * @return ori_left_foot_confidence value
4586  */
4587 float
4589 {
4590  return data->ori_left_foot_confidence;
4591 }
4592 
4593 /** Get maximum length of ori_left_foot_confidence value.
4594  * @return length of ori_left_foot_confidence value, can be length of the array or number of
4595  * maximum number of characters for a string
4596  */
4597 size_t
4599 {
4600  return 1;
4601 }
4602 
4603 /** Set ori_left_foot_confidence value.
4604  *
4605  Left foot position confidence.
4606  * @param new_ori_left_foot_confidence new ori_left_foot_confidence value
4607  */
4608 void
4609 HumanSkeletonInterface::set_ori_left_foot_confidence(const float new_ori_left_foot_confidence)
4610 {
4611  data->ori_left_foot_confidence = new_ori_left_foot_confidence;
4612  data_changed = true;
4613 }
4614 
4615 /** Get ori_right_hip value.
4616  *
4617  Right hip position vector.
4618  * @return ori_right_hip value
4619  */
4620 float *
4622 {
4623  return data->ori_right_hip;
4624 }
4625 
4626 /** Get ori_right_hip value at given index.
4627  *
4628  Right hip position vector.
4629  * @param index index of value
4630  * @return ori_right_hip value
4631  * @exception Exception thrown if index is out of bounds
4632  */
4633 float
4634 HumanSkeletonInterface::ori_right_hip(unsigned int index) const
4635 {
4636  if (index > 8) {
4637  throw Exception("Index value %u out of bounds (0..8)", index);
4638  }
4639  return data->ori_right_hip[index];
4641 
4642 /** Get maximum length of ori_right_hip value.
4643  * @return length of ori_right_hip value, can be length of the array or number of
4644  * maximum number of characters for a string
4645  */
4646 size_t
4648 {
4649  return 9;
4650 }
4651 
4652 /** Set ori_right_hip value.
4653  *
4654  Right hip position vector.
4655  * @param new_ori_right_hip new ori_right_hip value
4656  */
4657 void
4658 HumanSkeletonInterface::set_ori_right_hip(const float * new_ori_right_hip)
4659 {
4660  memcpy(data->ori_right_hip, new_ori_right_hip, sizeof(float) * 9);
4661  data_changed = true;
4662 }
4663 
4664 /** Set ori_right_hip value at given index.
4665  *
4666  Right hip position vector.
4667  * @param new_ori_right_hip new ori_right_hip value
4668  * @param index index for of the value
4669  */
4670 void
4671 HumanSkeletonInterface::set_ori_right_hip(unsigned int index, const float new_ori_right_hip)
4672 {
4673  if (index > 8) {
4674  throw Exception("Index value %u out of bounds (0..8)", index);
4675  }
4676  data->ori_right_hip[index] = new_ori_right_hip;
4678 }
4679 /** Get ori_right_hip_confidence value.
4680  *
4681  Right hip position confidence.
4682  * @return ori_right_hip_confidence value
4683  */
4684 float
4686 {
4687  return data->ori_right_hip_confidence;
4688 }
4689 
4690 /** Get maximum length of ori_right_hip_confidence value.
4691  * @return length of ori_right_hip_confidence value, can be length of the array or number of
4692  * maximum number of characters for a string
4693  */
4694 size_t
4696 {
4697  return 1;
4698 }
4699 
4700 /** Set ori_right_hip_confidence value.
4701  *
4702  Right hip position confidence.
4703  * @param new_ori_right_hip_confidence new ori_right_hip_confidence value
4704  */
4705 void
4706 HumanSkeletonInterface::set_ori_right_hip_confidence(const float new_ori_right_hip_confidence)
4707 {
4708  data->ori_right_hip_confidence = new_ori_right_hip_confidence;
4709  data_changed = true;
4710 }
4711 
4712 /** Get ori_right_knee value.
4713  *
4714  Right knee position vector.
4715  * @return ori_right_knee value
4716  */
4717 float *
4719 {
4720  return data->ori_right_knee;
4721 }
4722 
4723 /** Get ori_right_knee value at given index.
4724  *
4725  Right knee position vector.
4726  * @param index index of value
4727  * @return ori_right_knee value
4728  * @exception Exception thrown if index is out of bounds
4729  */
4730 float
4731 HumanSkeletonInterface::ori_right_knee(unsigned int index) const
4732 {
4733  if (index > 8) {
4734  throw Exception("Index value %u out of bounds (0..8)", index);
4735  }
4736  return data->ori_right_knee[index];
4738 
4739 /** Get maximum length of ori_right_knee value.
4740  * @return length of ori_right_knee value, can be length of the array or number of
4741  * maximum number of characters for a string
4742  */
4743 size_t
4745 {
4746  return 9;
4747 }
4748 
4749 /** Set ori_right_knee value.
4750  *
4751  Right knee position vector.
4752  * @param new_ori_right_knee new ori_right_knee value
4753  */
4754 void
4755 HumanSkeletonInterface::set_ori_right_knee(const float * new_ori_right_knee)
4756 {
4757  memcpy(data->ori_right_knee, new_ori_right_knee, sizeof(float) * 9);
4758  data_changed = true;
4759 }
4760 
4761 /** Set ori_right_knee value at given index.
4762  *
4763  Right knee position vector.
4764  * @param new_ori_right_knee new ori_right_knee value
4765  * @param index index for of the value
4766  */
4767 void
4768 HumanSkeletonInterface::set_ori_right_knee(unsigned int index, const float new_ori_right_knee)
4769 {
4770  if (index > 8) {
4771  throw Exception("Index value %u out of bounds (0..8)", index);
4772  }
4773  data->ori_right_knee[index] = new_ori_right_knee;
4775 }
4776 /** Get ori_right_knee_confidence value.
4777  *
4778  Right knee position confidence.
4779  * @return ori_right_knee_confidence value
4780  */
4781 float
4783 {
4784  return data->ori_right_knee_confidence;
4785 }
4786 
4787 /** Get maximum length of ori_right_knee_confidence value.
4788  * @return length of ori_right_knee_confidence value, can be length of the array or number of
4789  * maximum number of characters for a string
4790  */
4791 size_t
4793 {
4794  return 1;
4795 }
4796 
4797 /** Set ori_right_knee_confidence value.
4798  *
4799  Right knee position confidence.
4800  * @param new_ori_right_knee_confidence new ori_right_knee_confidence value
4801  */
4802 void
4803 HumanSkeletonInterface::set_ori_right_knee_confidence(const float new_ori_right_knee_confidence)
4804 {
4805  data->ori_right_knee_confidence = new_ori_right_knee_confidence;
4806  data_changed = true;
4807 }
4808 
4809 /** Get ori_right_ankle value.
4810  *
4811  Right ankle position vector.
4812  * @return ori_right_ankle value
4813  */
4814 float *
4816 {
4817  return data->ori_right_ankle;
4818 }
4819 
4820 /** Get ori_right_ankle value at given index.
4821  *
4822  Right ankle position vector.
4823  * @param index index of value
4824  * @return ori_right_ankle value
4825  * @exception Exception thrown if index is out of bounds
4826  */
4827 float
4828 HumanSkeletonInterface::ori_right_ankle(unsigned int index) const
4829 {
4830  if (index > 8) {
4831  throw Exception("Index value %u out of bounds (0..8)", index);
4832  }
4833  return data->ori_right_ankle[index];
4835 
4836 /** Get maximum length of ori_right_ankle value.
4837  * @return length of ori_right_ankle value, can be length of the array or number of
4838  * maximum number of characters for a string
4839  */
4840 size_t
4842 {
4843  return 9;
4844 }
4845 
4846 /** Set ori_right_ankle value.
4847  *
4848  Right ankle position vector.
4849  * @param new_ori_right_ankle new ori_right_ankle value
4850  */
4851 void
4852 HumanSkeletonInterface::set_ori_right_ankle(const float * new_ori_right_ankle)
4853 {
4854  memcpy(data->ori_right_ankle, new_ori_right_ankle, sizeof(float) * 9);
4855  data_changed = true;
4856 }
4857 
4858 /** Set ori_right_ankle value at given index.
4859  *
4860  Right ankle position vector.
4861  * @param new_ori_right_ankle new ori_right_ankle value
4862  * @param index index for of the value
4863  */
4864 void
4865 HumanSkeletonInterface::set_ori_right_ankle(unsigned int index, const float new_ori_right_ankle)
4866 {
4867  if (index > 8) {
4868  throw Exception("Index value %u out of bounds (0..8)", index);
4869  }
4870  data->ori_right_ankle[index] = new_ori_right_ankle;
4872 }
4873 /** Get ori_right_ankle_confidence value.
4874  *
4875  Right ankle position confidence.
4876  * @return ori_right_ankle_confidence value
4877  */
4878 float
4880 {
4881  return data->ori_right_ankle_confidence;
4882 }
4883 
4884 /** Get maximum length of ori_right_ankle_confidence value.
4885  * @return length of ori_right_ankle_confidence value, can be length of the array or number of
4886  * maximum number of characters for a string
4887  */
4888 size_t
4890 {
4891  return 1;
4892 }
4893 
4894 /** Set ori_right_ankle_confidence value.
4895  *
4896  Right ankle position confidence.
4897  * @param new_ori_right_ankle_confidence new ori_right_ankle_confidence value
4898  */
4899 void
4900 HumanSkeletonInterface::set_ori_right_ankle_confidence(const float new_ori_right_ankle_confidence)
4901 {
4902  data->ori_right_ankle_confidence = new_ori_right_ankle_confidence;
4903  data_changed = true;
4904 }
4905 
4906 /** Get ori_right_foot value.
4907  *
4908  Right foot position vector.
4909  * @return ori_right_foot value
4910  */
4911 float *
4913 {
4914  return data->ori_right_foot;
4915 }
4916 
4917 /** Get ori_right_foot value at given index.
4918  *
4919  Right foot position vector.
4920  * @param index index of value
4921  * @return ori_right_foot value
4922  * @exception Exception thrown if index is out of bounds
4923  */
4924 float
4925 HumanSkeletonInterface::ori_right_foot(unsigned int index) const
4926 {
4927  if (index > 8) {
4928  throw Exception("Index value %u out of bounds (0..8)", index);
4929  }
4930  return data->ori_right_foot[index];
4932 
4933 /** Get maximum length of ori_right_foot value.
4934  * @return length of ori_right_foot value, can be length of the array or number of
4935  * maximum number of characters for a string
4936  */
4937 size_t
4939 {
4940  return 9;
4941 }
4942 
4943 /** Set ori_right_foot value.
4944  *
4945  Right foot position vector.
4946  * @param new_ori_right_foot new ori_right_foot value
4947  */
4948 void
4949 HumanSkeletonInterface::set_ori_right_foot(const float * new_ori_right_foot)
4950 {
4951  memcpy(data->ori_right_foot, new_ori_right_foot, sizeof(float) * 9);
4952  data_changed = true;
4953 }
4954 
4955 /** Set ori_right_foot value at given index.
4956  *
4957  Right foot position vector.
4958  * @param new_ori_right_foot new ori_right_foot value
4959  * @param index index for of the value
4960  */
4961 void
4962 HumanSkeletonInterface::set_ori_right_foot(unsigned int index, const float new_ori_right_foot)
4963 {
4964  if (index > 8) {
4965  throw Exception("Index value %u out of bounds (0..8)", index);
4966  }
4967  data->ori_right_foot[index] = new_ori_right_foot;
4969 }
4970 /** Get ori_right_foot_confidence value.
4971  *
4972  Right foot position confidence.
4973  * @return ori_right_foot_confidence value
4974  */
4975 float
4977 {
4978  return data->ori_right_foot_confidence;
4979 }
4980 
4981 /** Get maximum length of ori_right_foot_confidence value.
4982  * @return length of ori_right_foot_confidence value, can be length of the array or number of
4983  * maximum number of characters for a string
4984  */
4985 size_t
4987 {
4988  return 1;
4989 }
4990 
4991 /** Set ori_right_foot_confidence value.
4992  *
4993  Right foot position confidence.
4994  * @param new_ori_right_foot_confidence new ori_right_foot_confidence value
4995  */
4996 void
4997 HumanSkeletonInterface::set_ori_right_foot_confidence(const float new_ori_right_foot_confidence)
4998 {
4999  data->ori_right_foot_confidence = new_ori_right_foot_confidence;
5000  data_changed = true;
5001 }
5002 
5003 /* =========== message create =========== */
5004 Message *
5006 {
5007  throw UnknownTypeException("The given type '%s' does not match any known "
5008  "message type for this interface type.", type);
5009 }
5010 
5012 /** Copy values from other interface.
5013  * @param other other interface to copy values from
5014  */
5015 void
5017 {
5018  const HumanSkeletonInterface *oi = dynamic_cast<const HumanSkeletonInterface *>(other);
5019  if (oi == NULL) {
5020  throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
5021  type(), other->type());
5022  }
5023  memcpy(data, oi->data, sizeof(HumanSkeletonInterface_data_t));
5024 }
5025 
5026 const char *
5027 HumanSkeletonInterface::enum_tostring(const char *enumtype, int val) const
5028 {
5029  if (strcmp(enumtype, "State") == 0) {
5030  return tostring_State((State)val);
5031  }
5032  throw UnknownTypeException("Unknown enum type %s", enumtype);
5034 
5035 /* =========== messages =========== */
5036 /** Check if message is valid and can be enqueued.
5037  * @param message Message to check
5038  * @return true if the message is valid, false otherwise.
5039  */
5040 bool
5041 HumanSkeletonInterface::message_valid(const Message *message) const
5042 {
5043  return false;
5044 }
5045 
5046 /// @cond INTERNALS
5047 EXPORT_INTERFACE(HumanSkeletonInterface)
5048 /// @endcond
5049 
5050 
5051 } // end namespace fawkes
fawkes::HumanSkeletonInterface::maxlenof_pos_right_ankle_confidence
size_t maxlenof_pos_right_ankle_confidence() const
Get maximum length of pos_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2583
fawkes::HumanSkeletonInterface::set_ori_right_shoulder
void set_ori_right_shoulder(unsigned int index, const float new_ori_right_shoulder)
Set ori_right_shoulder value at given index.
Definition: HumanSkeletonInterface.cpp:3804
fawkes::HumanSkeletonInterface::set_pos_left_elbow_confidence
void set_pos_left_elbow_confidence(const float new_pos_left_elbow_confidence)
Set pos_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1042
fawkes::HumanSkeletonInterface::ori_right_foot
float * ori_right_foot() const
Get ori_right_foot value.
Definition: HumanSkeletonInterface.cpp:4918
fawkes::HumanSkeletonInterface::pos_right_foot
float * pos_right_foot() const
Get pos_right_foot value.
Definition: HumanSkeletonInterface.cpp:2606
fawkes::Interface::data_ptr
void * data_ptr
Definition: interface.h:224
fawkes::HumanSkeletonInterface::maxlenof_pos_right_hip_confidence
size_t maxlenof_pos_right_hip_confidence() const
Get maximum length of pos_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:2389
fawkes::HumanSkeletonInterface::maxlenof_ori_right_hand
size_t maxlenof_ori_right_hand() const
Get maximum length of ori_right_hand value.
Definition: HumanSkeletonInterface.cpp:4071
fawkes::HumanSkeletonInterface::set_ori_right_knee_confidence
void set_ori_right_knee_confidence(const float new_ori_right_knee_confidence)
Set ori_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4809
fawkes::HumanSkeletonInterface::copy_values
virtual void copy_values(const Interface *other)
Copy values from other interface.
Definition: HumanSkeletonInterface.cpp:5022
fawkes::HumanSkeletonInterface::maxlenof_pos_left_shoulder
size_t maxlenof_pos_left_shoulder() const
Get maximum length of pos_left_shoulder value.
Definition: HumanSkeletonInterface.cpp:886
fawkes::HumanSkeletonInterface::pos_right_hip_confidence
float pos_right_hip_confidence() const
Get pos_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:2379
fawkes::HumanSkeletonInterface::maxlenof_pos_right_shoulder_confidence
size_t maxlenof_pos_right_shoulder_confidence() const
Get maximum length of pos_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:1516
fawkes::HumanSkeletonInterface::set_ori_right_foot
void set_ori_right_foot(unsigned int index, const float new_ori_right_foot)
Set ori_right_foot value at given index.
Definition: HumanSkeletonInterface.cpp:4968
fawkes::HumanSkeletonInterface::set_pos_right_wrist_confidence
void set_pos_right_wrist_confidence(const float new_pos_right_wrist_confidence)
Set pos_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1721
fawkes::HumanSkeletonInterface::pos_left_ankle_confidence
float pos_left_ankle_confidence() const
Get pos_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2185
fawkes::HumanSkeletonInterface::set_ori_left_ankle
void set_ori_left_ankle(unsigned int index, const float new_ori_left_ankle)
Set ori_left_ankle value at given index.
Definition: HumanSkeletonInterface.cpp:4483
fawkes::HumanSkeletonInterface::maxlenof_pos_left_wrist
size_t maxlenof_pos_left_wrist() const
Get maximum length of pos_left_wrist value.
Definition: HumanSkeletonInterface.cpp:1080
fawkes::HumanSkeletonInterface::set_ori_left_hand
void set_ori_left_hand(unsigned int index, const float new_ori_left_hand)
Set ori_left_hand value at given index.
Definition: HumanSkeletonInterface.cpp:3513
fawkes::HumanSkeletonInterface::set_pos_left_foot_confidence
void set_pos_left_foot_confidence(const float new_pos_left_foot_confidence)
Set pos_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2303
fawkes::HumanSkeletonInterface::ori_right_ankle
float * ori_right_ankle() const
Get ori_right_ankle value.
Definition: HumanSkeletonInterface.cpp:4821
fawkes::HumanSkeletonInterface::pos_left_elbow_confidence
float pos_left_elbow_confidence() const
Get pos_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1021
fawkes::HumanSkeletonInterface::set_pos_left_elbow
void set_pos_left_elbow(unsigned int index, const float new_pos_left_elbow)
Set pos_left_elbow value at given index.
Definition: HumanSkeletonInterface.cpp:1007
fawkes::HumanSkeletonInterface::set_pos_neck
void set_pos_neck(unsigned int index, const float new_pos_neck)
Set pos_neck value at given index.
Definition: HumanSkeletonInterface.cpp:530
fawkes::HumanSkeletonInterface::set_pos_left_hand_confidence
void set_pos_left_hand_confidence(const float new_pos_left_hand_confidence)
Set pos_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1236
fawkes::HumanSkeletonInterface::pos_left_wrist
float * pos_left_wrist() const
Get pos_left_wrist value.
Definition: HumanSkeletonInterface.cpp:1054
fawkes::HumanSkeletonInterface::set_ori_right_collar
void set_ori_right_collar(unsigned int index, const float new_ori_right_collar)
Set ori_right_collar value at given index.
Definition: HumanSkeletonInterface.cpp:3707
fawkes::HumanSkeletonInterface::maxlenof_pos_head_confidence
size_t maxlenof_pos_head_confidence() const
Get maximum length of pos_head_confidence value.
Definition: HumanSkeletonInterface.cpp:461
fawkes::HumanSkeletonInterface::pos_head
float * pos_head() const
Get pos_head value.
Definition: HumanSkeletonInterface.cpp:390
fawkes::HumanSkeletonInterface::maxlenof_pos_right_hip
size_t maxlenof_pos_right_hip() const
Get maximum length of pos_right_hip value.
Definition: HumanSkeletonInterface.cpp:2341
fawkes::HumanSkeletonInterface::ori_right_foot_confidence
float ori_right_foot_confidence() const
Get ori_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:4982
fawkes::HumanSkeletonInterface::set_pos_left_ankle
void set_pos_left_ankle(unsigned int index, const float new_pos_left_ankle)
Set pos_left_ankle value at given index.
Definition: HumanSkeletonInterface.cpp:2171
fawkes::HumanSkeletonInterface::ori_left_hand_confidence
float ori_left_hand_confidence() const
Get ori_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:3527
fawkes::HumanSkeletonInterface::pos_right_shoulder_confidence
float pos_right_shoulder_confidence() const
Get pos_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:1506
fawkes::HumanSkeletonInterface::maxlenof_ori_right_foot_confidence
size_t maxlenof_ori_right_foot_confidence() const
Get maximum length of ori_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:4992
fawkes::HumanSkeletonInterface::maxlenof_ori_right_shoulder
size_t maxlenof_ori_right_shoulder() const
Get maximum length of ori_right_shoulder value.
Definition: HumanSkeletonInterface.cpp:3780
fawkes::HumanSkeletonInterface::maxlenof_ori_right_elbow_confidence
size_t maxlenof_ori_right_elbow_confidence() const
Get maximum length of ori_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3925
fawkes::HumanSkeletonInterface::maxlenof_pos_neck
size_t maxlenof_pos_neck() const
Get maximum length of pos_neck value.
Definition: HumanSkeletonInterface.cpp:508
fawkes::HumanSkeletonInterface::set_pose
void set_pose(const char *new_pose)
Set pose value.
Definition: HumanSkeletonInterface.cpp:318
fawkes::HumanSkeletonInterface::set_pos_right_hand_confidence
void set_pos_right_hand_confidence(const float new_pos_right_hand_confidence)
Set pos_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1818
fawkes::HumanSkeletonInterface::maxlenof_pos_left_shoulder_confidence
size_t maxlenof_pos_left_shoulder_confidence() const
Get maximum length of pos_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:934
fawkes::HumanSkeletonInterface::set_pos_right_hand
void set_pos_right_hand(unsigned int index, const float new_pos_right_hand)
Set pos_right_hand value at given index.
Definition: HumanSkeletonInterface.cpp:1783
fawkes::HumanSkeletonInterface::set_pos_right_elbow_confidence
void set_pos_right_elbow_confidence(const float new_pos_right_elbow_confidence)
Set pos_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1624
fawkes::HumanSkeletonInterface::ori_left_hand
float * ori_left_hand() const
Get ori_left_hand value.
Definition: HumanSkeletonInterface.cpp:3463
fawkes::HumanSkeletonInterface::maxlenof_pos_right_fingertip
size_t maxlenof_pos_right_fingertip() const
Get maximum length of pos_right_fingertip value.
Definition: HumanSkeletonInterface.cpp:1856
fawkes::HumanSkeletonInterface::pos_right_fingertip_confidence
float pos_right_fingertip_confidence() const
Get pos_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1894
fawkes::HumanSkeletonInterface::pos_left_collar
float * pos_left_collar() const
Get pos_left_collar value.
Definition: HumanSkeletonInterface.cpp:763
fawkes::HumanSkeletonInterface::set_pos_right_ankle_confidence
void set_pos_right_ankle_confidence(const float new_pos_right_ankle_confidence)
Set pos_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2594
fawkes::HumanSkeletonInterface::maxlenof_pos_right_elbow
size_t maxlenof_pos_right_elbow() const
Get maximum length of pos_right_elbow value.
Definition: HumanSkeletonInterface.cpp:1565
fawkes::HumanSkeletonInterface::pos_left_wrist_confidence
float pos_left_wrist_confidence() const
Get pos_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1118
fawkes::HumanSkeletonInterface::maxlenof_ori_head_confidence
size_t maxlenof_ori_head_confidence() const
Get maximum length of ori_head_confidence value.
Definition: HumanSkeletonInterface.cpp:2773
fawkes::HumanSkeletonInterface::maxlenof_pos_right_elbow_confidence
size_t maxlenof_pos_right_elbow_confidence() const
Get maximum length of pos_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1613
fawkes::HumanSkeletonInterface::set_pos_torso_confidence
void set_pos_torso_confidence(const float new_pos_torso_confidence)
Set pos_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:658
fawkes::HumanSkeletonInterface::maxlenof_pos_left_collar_confidence
size_t maxlenof_pos_left_collar_confidence() const
Get maximum length of pos_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:837
fawkes::HumanSkeletonInterface::pos_right_foot_confidence
float pos_right_foot_confidence() const
Get pos_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2670
fawkes::HumanSkeletonInterface::maxlenof_pos_left_fingertip_confidence
size_t maxlenof_pos_left_fingertip_confidence() const
Get maximum length of pos_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1322
fawkes::Message
Definition: message.h:41
fawkes::HumanSkeletonInterface::maxlenof_pos_left_elbow
size_t maxlenof_pos_left_elbow() const
Get maximum length of pos_left_elbow value.
Definition: HumanSkeletonInterface.cpp:983
fawkes::HumanSkeletonInterface::set_ori_right_wrist_confidence
void set_ori_right_wrist_confidence(const float new_ori_right_wrist_confidence)
Set ori_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:4033
fawkes::HumanSkeletonInterface::ori_left_shoulder_confidence
float ori_left_shoulder_confidence() const
Get ori_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3236
fawkes::HumanSkeletonInterface::maxlenof_state
size_t maxlenof_state() const
Get maximum length of state value.
Definition: HumanSkeletonInterface.cpp:203
fawkes::HumanSkeletonInterface::ori_right_ankle_confidence
float ori_right_ankle_confidence() const
Get ori_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4885
fawkes::HumanSkeletonInterface::pos_left_collar_confidence
float pos_left_collar_confidence() const
Get pos_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:827
fawkes::HumanSkeletonInterface::pos_left_knee_confidence
float pos_left_knee_confidence() const
Get pos_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2088
fawkes::HumanSkeletonInterface::ori_right_hip_confidence
float ori_right_hip_confidence() const
Get ori_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4691
fawkes::HumanSkeletonInterface::set_ori_torso
void set_ori_torso(unsigned int index, const float new_ori_torso)
Set ori_torso value at given index.
Definition: HumanSkeletonInterface.cpp:2935
fawkes::HumanSkeletonInterface::set_ori_left_elbow
void set_ori_left_elbow(unsigned int index, const float new_ori_left_elbow)
Set ori_left_elbow value at given index.
Definition: HumanSkeletonInterface.cpp:3319
fawkes::HumanSkeletonInterface::maxlenof_pos_neck_confidence
size_t maxlenof_pos_neck_confidence() const
Get maximum length of pos_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:554
fawkes::Message::data_ptr
void * data_ptr
Definition: message.h:125
fawkes::HumanSkeletonInterface::maxlenof_pos_left_hand
size_t maxlenof_pos_left_hand() const
Get maximum length of pos_left_hand value.
Definition: HumanSkeletonInterface.cpp:1177
fawkes::HumanSkeletonInterface::maxlenof_ori_left_foot_confidence
size_t maxlenof_ori_left_foot_confidence() const
Get maximum length of ori_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:4604
fawkes::HumanSkeletonInterface::message_valid
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
Definition: HumanSkeletonInterface.cpp:5047
fawkes::HumanSkeletonInterface
Definition: HumanSkeletonInterface.h:39
fawkes::HumanSkeletonInterface::set_ori_left_foot_confidence
void set_ori_left_foot_confidence(const float new_ori_left_foot_confidence)
Set ori_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:4615
fawkes::HumanSkeletonInterface::ori_right_collar_confidence
float ori_right_collar_confidence() const
Get ori_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3721
fawkes::HumanSkeletonInterface::maxlenof_pos_left_collar
size_t maxlenof_pos_left_collar() const
Get maximum length of pos_left_collar value.
Definition: HumanSkeletonInterface.cpp:789
fawkes::HumanSkeletonInterface::maxlenof_ori_right_hip_confidence
size_t maxlenof_ori_right_hip_confidence() const
Get maximum length of ori_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4701
fawkes::HumanSkeletonInterface::set_pos_right_knee_confidence
void set_pos_right_knee_confidence(const float new_pos_right_knee_confidence)
Set pos_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2497
fawkes::HumanSkeletonInterface::pos_right_knee
float * pos_right_knee() const
Get pos_right_knee value.
Definition: HumanSkeletonInterface.cpp:2412
fawkes::HumanSkeletonInterface::maxlenof_ori_right_hip
size_t maxlenof_ori_right_hip() const
Get maximum length of ori_right_hip value.
Definition: HumanSkeletonInterface.cpp:4653
fawkes::HumanSkeletonInterface::set_pos_right_foot_confidence
void set_pos_right_foot_confidence(const float new_pos_right_foot_confidence)
Set pos_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2691
fawkes::IFT_FLOAT
@ IFT_FLOAT
float field
Definition: types.h:60
fawkes::HumanSkeletonInterface::maxlenof_pos_left_foot_confidence
size_t maxlenof_pos_left_foot_confidence() const
Get maximum length of pos_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2292
fawkes::IFT_ENUM
@ IFT_ENUM
field with interface specific enum type
Definition: types.h:64
fawkes::Message::data_ts
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:135
fawkes::HumanSkeletonInterface::set_ori_left_wrist_confidence
void set_ori_left_wrist_confidence(const float new_ori_left_wrist_confidence)
Set ori_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:3451
fawkes::HumanSkeletonInterface::pos_right_wrist_confidence
float pos_right_wrist_confidence() const
Get pos_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1700
fawkes::HumanSkeletonInterface::maxlenof_pos_left_hip
size_t maxlenof_pos_left_hip() const
Get maximum length of pos_left_hip value.
Definition: HumanSkeletonInterface.cpp:1953
fawkes::HumanSkeletonInterface::ori_right_wrist_confidence
float ori_right_wrist_confidence() const
Get ori_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:4012
fawkes::HumanSkeletonInterface::ori_right_shoulder_confidence
float ori_right_shoulder_confidence() const
Get ori_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3818
fawkes::HumanSkeletonInterface::maxlenof_pos_left_ankle_confidence
size_t maxlenof_pos_left_ankle_confidence() const
Get maximum length of pos_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2195
fawkes::HumanSkeletonInterface::maxlenof_pos_right_wrist
size_t maxlenof_pos_right_wrist() const
Get maximum length of pos_right_wrist value.
Definition: HumanSkeletonInterface.cpp:1662
fawkes::IFT_UINT32
@ IFT_UINT32
32 bit unsigned integer field
Definition: types.h:57
fawkes::HumanSkeletonInterface::set_ori_right_hip
void set_ori_right_hip(unsigned int index, const float new_ori_right_hip)
Set ori_right_hip value at given index.
Definition: HumanSkeletonInterface.cpp:4677
fawkes::HumanSkeletonInterface::maxlenof_ori_left_ankle
size_t maxlenof_ori_left_ankle() const
Get maximum length of ori_left_ankle value.
Definition: HumanSkeletonInterface.cpp:4459
fawkes::HumanSkeletonInterface::maxlenof_pos_right_shoulder
size_t maxlenof_pos_right_shoulder() const
Get maximum length of pos_right_shoulder value.
Definition: HumanSkeletonInterface.cpp:1468
fawkes::HumanSkeletonInterface::maxlenof_ori_right_elbow
size_t maxlenof_ori_right_elbow() const
Get maximum length of ori_right_elbow value.
Definition: HumanSkeletonInterface.cpp:3877
fawkes::HumanSkeletonInterface::pos_left_ankle
float * pos_left_ankle() const
Get pos_left_ankle value.
Definition: HumanSkeletonInterface.cpp:2121
fawkes::HumanSkeletonInterface::maxlenof_ori_waist
size_t maxlenof_ori_waist() const
Get maximum length of ori_waist value.
Definition: HumanSkeletonInterface.cpp:3006
fawkes::HumanSkeletonInterface::set_pos_head
void set_pos_head(unsigned int index, const float new_pos_head)
Set pos_head value at given index.
Definition: HumanSkeletonInterface.cpp:437
fawkes::HumanSkeletonInterface::set_pos_head_confidence
void set_pos_head_confidence(const float new_pos_head_confidence)
Set pos_head_confidence value.
Definition: HumanSkeletonInterface.cpp:472
fawkes::HumanSkeletonInterface::maxlenof_pos_right_collar_confidence
size_t maxlenof_pos_right_collar_confidence() const
Get maximum length of pos_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:1419
fawkes::HumanSkeletonInterface::set_user_id
void set_user_id(const uint32_t new_user_id)
Set user_id value.
Definition: HumanSkeletonInterface.cpp:244
fawkes::HumanSkeletonInterface::set_pos_left_ankle_confidence
void set_pos_left_ankle_confidence(const float new_pos_left_ankle_confidence)
Set pos_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2206
fawkes::HumanSkeletonInterface::pos_head_confidence
float pos_head_confidence() const
Get pos_head_confidence value.
Definition: HumanSkeletonInterface.cpp:451
fawkes::HumanSkeletonInterface::pos_torso_confidence
float pos_torso_confidence() const
Get pos_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:637
fawkes::HumanSkeletonInterface::set_pos_left_fingertip
void set_pos_left_fingertip(unsigned int index, const float new_pos_left_fingertip)
Set pos_left_fingertip value at given index.
Definition: HumanSkeletonInterface.cpp:1298
fawkes::HumanSkeletonInterface::com
float * com() const
Get com value.
Definition: HumanSkeletonInterface.cpp:330
fawkes::HumanSkeletonInterface::ori_neck
float * ori_neck() const
Get ori_neck value.
Definition: HumanSkeletonInterface.cpp:2795
fawkes::Interface::type
const char * type() const
Get type of interface.
Definition: interface.cpp:645
fawkes::HumanSkeletonInterface::ori_right_knee_confidence
float ori_right_knee_confidence() const
Get ori_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4788
fawkes::HumanSkeletonInterface::set_pos_left_hand
void set_pos_left_hand(unsigned int index, const float new_pos_left_hand)
Set pos_left_hand value at given index.
Definition: HumanSkeletonInterface.cpp:1201
fawkes::HumanSkeletonInterface::set_ori_left_wrist
void set_ori_left_wrist(unsigned int index, const float new_ori_left_wrist)
Set ori_left_wrist value at given index.
Definition: HumanSkeletonInterface.cpp:3416
fawkes::HumanSkeletonInterface::ori_torso_confidence
float ori_torso_confidence() const
Get ori_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:2949
fawkes::HumanSkeletonInterface::maxlenof_ori_left_shoulder_confidence
size_t maxlenof_ori_left_shoulder_confidence() const
Get maximum length of ori_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3246
fawkes::HumanSkeletonInterface::maxlenof_ori_left_fingertip_confidence
size_t maxlenof_ori_left_fingertip_confidence() const
Get maximum length of ori_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:3634
fawkes::HumanSkeletonInterface::set_ori_left_knee_confidence
void set_ori_left_knee_confidence(const float new_ori_left_knee_confidence)
Set ori_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4421
fawkes::HumanSkeletonInterface::set_pos_left_collar
void set_pos_left_collar(unsigned int index, const float new_pos_left_collar)
Set pos_left_collar value at given index.
Definition: HumanSkeletonInterface.cpp:813
fawkes::HumanSkeletonInterface::maxlenof_pos_left_knee_confidence
size_t maxlenof_pos_left_knee_confidence() const
Get maximum length of pos_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2098
fawkes::HumanSkeletonInterface::set_ori_left_shoulder_confidence
void set_ori_left_shoulder_confidence(const float new_ori_left_shoulder_confidence)
Set ori_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3257
fawkes::HumanSkeletonInterface::ori_right_hand
float * ori_right_hand() const
Get ori_right_hand value.
Definition: HumanSkeletonInterface.cpp:4045
fawkes::HumanSkeletonInterface::set_pos_waist
void set_pos_waist(unsigned int index, const float new_pos_waist)
Set pos_waist value at given index.
Definition: HumanSkeletonInterface.cpp:716
fawkes::HumanSkeletonInterface::maxlenof_ori_left_elbow
size_t maxlenof_ori_left_elbow() const
Get maximum length of ori_left_elbow value.
Definition: HumanSkeletonInterface.cpp:3295
fawkes::HumanSkeletonInterface::maxlenof_ori_waist_confidence
size_t maxlenof_ori_waist_confidence() const
Get maximum length of ori_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:3052
fawkes::HumanSkeletonInterface::ori_right_fingertip
float * ori_right_fingertip() const
Get ori_right_fingertip value.
Definition: HumanSkeletonInterface.cpp:4142
fawkes::HumanSkeletonInterface::set_state
void set_state(const State new_state)
Set state value.
Definition: HumanSkeletonInterface.cpp:213
fawkes::HumanSkeletonInterface::maxlenof_ori_torso
size_t maxlenof_ori_torso() const
Get maximum length of ori_torso value.
Definition: HumanSkeletonInterface.cpp:2913
fawkes::HumanSkeletonInterface::ori_left_hip
float * ori_left_hip() const
Get ori_left_hip value.
Definition: HumanSkeletonInterface.cpp:4239
fawkes::HumanSkeletonInterface::maxlenof_ori_right_hand_confidence
size_t maxlenof_ori_right_hand_confidence() const
Get maximum length of ori_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:4119
fawkes::HumanSkeletonInterface::set_ori_right_collar_confidence
void set_ori_right_collar_confidence(const float new_ori_right_collar_confidence)
Set ori_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3742
fawkes::HumanSkeletonInterface::ori_left_collar_confidence
float ori_left_collar_confidence() const
Get ori_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3139
fawkes::HumanSkeletonInterface::set_ori_right_hand
void set_ori_right_hand(unsigned int index, const float new_ori_right_hand)
Set ori_right_hand value at given index.
Definition: HumanSkeletonInterface.cpp:4095
fawkes::HumanSkeletonInterface::tostring_State
const char * tostring_State(State value) const
Convert State constant to string.
Definition: HumanSkeletonInterface.cpp:177
fawkes::HumanSkeletonInterface::maxlenof_ori_left_elbow_confidence
size_t maxlenof_ori_left_elbow_confidence() const
Get maximum length of ori_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3343
fawkes::HumanSkeletonInterface::maxlenof_pos_left_fingertip
size_t maxlenof_pos_left_fingertip() const
Get maximum length of pos_left_fingertip value.
Definition: HumanSkeletonInterface.cpp:1274
fawkes::HumanSkeletonInterface::ori_left_knee
float * ori_left_knee() const
Get ori_left_knee value.
Definition: HumanSkeletonInterface.cpp:4336
fawkes::HumanSkeletonInterface::ori_left_knee_confidence
float ori_left_knee_confidence() const
Get ori_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4400
fawkes::HumanSkeletonInterface::set_pos_right_hip_confidence
void set_pos_right_hip_confidence(const float new_pos_right_hip_confidence)
Set pos_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:2400
fawkes::HumanSkeletonInterface::ori_left_elbow
float * ori_left_elbow() const
Get ori_left_elbow value.
Definition: HumanSkeletonInterface.cpp:3269
fawkes::HumanSkeletonInterface::set_pos_left_foot
void set_pos_left_foot(unsigned int index, const float new_pos_left_foot)
Set pos_left_foot value at given index.
Definition: HumanSkeletonInterface.cpp:2268
fawkes::HumanSkeletonInterface::create_message
virtual Message * create_message(const char *type) const
Definition: HumanSkeletonInterface.cpp:5011
fawkes::HumanSkeletonInterface::set_pos_left_wrist
void set_pos_left_wrist(unsigned int index, const float new_pos_left_wrist)
Set pos_left_wrist value at given index.
Definition: HumanSkeletonInterface.cpp:1104
fawkes::HumanSkeletonInterface::set_pos_right_foot
void set_pos_right_foot(unsigned int index, const float new_pos_right_foot)
Set pos_right_foot value at given index.
Definition: HumanSkeletonInterface.cpp:2656
fawkes::HumanSkeletonInterface::set_pos_right_shoulder
void set_pos_right_shoulder(unsigned int index, const float new_pos_right_shoulder)
Set pos_right_shoulder value at given index.
Definition: HumanSkeletonInterface.cpp:1492
fawkes::HumanSkeletonInterface::pos_left_fingertip
float * pos_left_fingertip() const
Get pos_left_fingertip value.
Definition: HumanSkeletonInterface.cpp:1248
fawkes::HumanSkeletonInterface::set_ori_waist_confidence
void set_ori_waist_confidence(const float new_ori_waist_confidence)
Set ori_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:3063
fawkes::HumanSkeletonInterface::maxlenof_ori_left_wrist_confidence
size_t maxlenof_ori_left_wrist_confidence() const
Get maximum length of ori_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:3440
fawkes::HumanSkeletonInterface::maxlenof_ori_left_hand_confidence
size_t maxlenof_ori_left_hand_confidence() const
Get maximum length of ori_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:3537
fawkes::TypeMismatchException
Definition: software.h:49
fawkes::HumanSkeletonInterface::maxlenof_pos_left_elbow_confidence
size_t maxlenof_pos_left_elbow_confidence() const
Get maximum length of pos_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1031
fawkes::Interface::data_changed
bool data_changed
Definition: interface.h:226
fawkes::HumanSkeletonInterface::ori_right_hand_confidence
float ori_right_hand_confidence() const
Get ori_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:4109
fawkes::HumanSkeletonInterface::maxlenof_pos_right_knee
size_t maxlenof_pos_right_knee() const
Get maximum length of pos_right_knee value.
Definition: HumanSkeletonInterface.cpp:2438
fawkes::HumanSkeletonInterface::maxlenof_pose
size_t maxlenof_pose() const
Get maximum length of pose value.
Definition: HumanSkeletonInterface.cpp:308
fawkes::HumanSkeletonInterface::set_ori_right_ankle
void set_ori_right_ankle(unsigned int index, const float new_ori_right_ankle)
Set ori_right_ankle value at given index.
Definition: HumanSkeletonInterface.cpp:4871
fawkes::HumanSkeletonInterface::set_visibility_history
void set_visibility_history(const int32_t new_visibility_history)
Set visibility_history value.
Definition: HumanSkeletonInterface.cpp:287
fawkes::HumanSkeletonInterface::set_pos_left_shoulder_confidence
void set_pos_left_shoulder_confidence(const float new_pos_left_shoulder_confidence)
Set pos_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:945
fawkes::HumanSkeletonInterface::pos_left_hand_confidence
float pos_left_hand_confidence() const
Get pos_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1215
fawkes::HumanSkeletonInterface::pos_right_elbow_confidence
float pos_right_elbow_confidence() const
Get pos_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:1603
fawkes::HumanSkeletonInterface::pos_left_hand
float * pos_left_hand() const
Get pos_left_hand value.
Definition: HumanSkeletonInterface.cpp:1151
fawkes::HumanSkeletonInterface::pos_right_elbow
float * pos_right_elbow() const
Get pos_right_elbow value.
Definition: HumanSkeletonInterface.cpp:1539
fawkes::IFT_INT32
@ IFT_INT32
32 bit integer field
Definition: types.h:56
fawkes::HumanSkeletonInterface::set_com
void set_com(unsigned int index, const float new_com)
Set com value at given index.
Definition: HumanSkeletonInterface.cpp:377
fawkes::HumanSkeletonInterface::visibility_history
int32_t visibility_history() const
Get visibility_history value.
Definition: HumanSkeletonInterface.cpp:261
fawkes::HumanSkeletonInterface::pos_torso
float * pos_torso() const
Get pos_torso value.
Definition: HumanSkeletonInterface.cpp:576
fawkes::HumanSkeletonInterface::set_ori_right_hip_confidence
void set_ori_right_hip_confidence(const float new_ori_right_hip_confidence)
Set ori_right_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4712
fawkes::UnknownTypeException
Definition: software.h:55
fawkes::HumanSkeletonInterface::state
State state() const
Get state value.
Definition: HumanSkeletonInterface.cpp:193
fawkes::HumanSkeletonInterface::set_ori_right_wrist
void set_ori_right_wrist(unsigned int index, const float new_ori_right_wrist)
Set ori_right_wrist value at given index.
Definition: HumanSkeletonInterface.cpp:3998
fawkes::HumanSkeletonInterface::set_ori_right_ankle_confidence
void set_ori_right_ankle_confidence(const float new_ori_right_ankle_confidence)
Set ori_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4906
fawkes::HumanSkeletonInterface::set_ori_left_fingertip
void set_ori_left_fingertip(unsigned int index, const float new_ori_left_fingertip)
Set ori_left_fingertip value at given index.
Definition: HumanSkeletonInterface.cpp:3610
fawkes::HumanSkeletonInterface::set_ori_left_collar
void set_ori_left_collar(unsigned int index, const float new_ori_left_collar)
Set ori_left_collar value at given index.
Definition: HumanSkeletonInterface.cpp:3125
fawkes::HumanSkeletonInterface::ori_right_wrist
float * ori_right_wrist() const
Get ori_right_wrist value.
Definition: HumanSkeletonInterface.cpp:3948
fawkes::HumanSkeletonInterface::ori_left_hip_confidence
float ori_left_hip_confidence() const
Get ori_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4303
fawkes::HumanSkeletonInterface::set_ori_right_shoulder_confidence
void set_ori_right_shoulder_confidence(const float new_ori_right_shoulder_confidence)
Set ori_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3839
fawkes::HumanSkeletonInterface::maxlenof_pos_right_wrist_confidence
size_t maxlenof_pos_right_wrist_confidence() const
Get maximum length of pos_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1710
fawkes::HumanSkeletonInterface::set_pos_neck_confidence
void set_pos_neck_confidence(const float new_pos_neck_confidence)
Set pos_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:565
fawkes::HumanSkeletonInterface::ori_right_elbow_confidence
float ori_right_elbow_confidence() const
Get ori_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3915
fawkes::HumanSkeletonInterface::pos_right_ankle_confidence
float pos_right_ankle_confidence() const
Get pos_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:2573
fawkes::HumanSkeletonInterface::set_ori_left_fingertip_confidence
void set_ori_left_fingertip_confidence(const float new_ori_left_fingertip_confidence)
Set ori_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:3645
fawkes
fawkes::HumanSkeletonInterface::set_pos_left_hip_confidence
void set_pos_left_hip_confidence(const float new_pos_left_hip_confidence)
Set pos_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:2012
fawkes::Interface::set_hash
void set_hash(unsigned char *ihash)
Set hash.
Definition: interface.cpp:321
fawkes::HumanSkeletonInterface::ori_left_wrist_confidence
float ori_left_wrist_confidence() const
Get ori_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:3430
fawkes::HumanSkeletonInterface::maxlenof_pos_left_hip_confidence
size_t maxlenof_pos_left_hip_confidence() const
Get maximum length of pos_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:2001
fawkes::HumanSkeletonInterface::ori_right_hip
float * ori_right_hip() const
Get ori_right_hip value.
Definition: HumanSkeletonInterface.cpp:4627
fawkes::Message::data_size
unsigned int data_size
Definition: message.h:126
fawkes::HumanSkeletonInterface::set_ori_right_knee
void set_ori_right_knee(unsigned int index, const float new_ori_right_knee)
Set ori_right_knee value at given index.
Definition: HumanSkeletonInterface.cpp:4774
fawkes::HumanSkeletonInterface::ori_right_knee
float * ori_right_knee() const
Get ori_right_knee value.
Definition: HumanSkeletonInterface.cpp:4724
fawkes::HumanSkeletonInterface::maxlenof_pos_right_ankle
size_t maxlenof_pos_right_ankle() const
Get maximum length of pos_right_ankle value.
Definition: HumanSkeletonInterface.cpp:2535
fawkes::HumanSkeletonInterface::maxlenof_pos_waist
size_t maxlenof_pos_waist() const
Get maximum length of pos_waist value.
Definition: HumanSkeletonInterface.cpp:694
fawkes::HumanSkeletonInterface::maxlenof_pos_right_foot_confidence
size_t maxlenof_pos_right_foot_confidence() const
Get maximum length of pos_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2680
fawkes::HumanSkeletonInterface::set_ori_left_hip_confidence
void set_ori_left_hip_confidence(const float new_ori_left_hip_confidence)
Set ori_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4324
fawkes::HumanSkeletonInterface::maxlenof_pos_right_knee_confidence
size_t maxlenof_pos_right_knee_confidence() const
Get maximum length of pos_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2486
fawkes::HumanSkeletonInterface::set_pos_right_collar
void set_pos_right_collar(unsigned int index, const float new_pos_right_collar)
Set pos_right_collar value at given index.
Definition: HumanSkeletonInterface.cpp:1395
fawkes::HumanSkeletonInterface::pos_left_hip
float * pos_left_hip() const
Get pos_left_hip value.
Definition: HumanSkeletonInterface.cpp:1927
fawkes::HumanSkeletonInterface::set_ori_head
void set_ori_head(unsigned int index, const float new_ori_head)
Set ori_head value at given index.
Definition: HumanSkeletonInterface.cpp:2749
fawkes::HumanSkeletonInterface::set_ori_left_ankle_confidence
void set_ori_left_ankle_confidence(const float new_ori_left_ankle_confidence)
Set ori_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4518
fawkes::HumanSkeletonInterface::ori_left_fingertip
float * ori_left_fingertip() const
Get ori_left_fingertip value.
Definition: HumanSkeletonInterface.cpp:3560
fawkes::HumanSkeletonInterface::maxlenof_pos_torso
size_t maxlenof_pos_torso() const
Get maximum length of pos_torso value.
Definition: HumanSkeletonInterface.cpp:601
fawkes::HumanSkeletonInterface::set_pos_right_knee
void set_pos_right_knee(unsigned int index, const float new_pos_right_knee)
Set pos_right_knee value at given index.
Definition: HumanSkeletonInterface.cpp:2462
fawkes::Interface
Definition: interface.h:78
fawkes::HumanSkeletonInterface::set_pos_left_fingertip_confidence
void set_pos_left_fingertip_confidence(const float new_pos_left_fingertip_confidence)
Set pos_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1333
fawkes::HumanSkeletonInterface::set_pos_left_hip
void set_pos_left_hip(unsigned int index, const float new_pos_left_hip)
Set pos_left_hip value at given index.
Definition: HumanSkeletonInterface.cpp:1977
fawkes::HumanSkeletonInterface::pos_waist_confidence
float pos_waist_confidence() const
Get pos_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:730
fawkes::HumanSkeletonInterface::maxlenof_ori_left_ankle_confidence
size_t maxlenof_ori_left_ankle_confidence() const
Get maximum length of ori_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4507
fawkes::HumanSkeletonInterface::ori_left_wrist
float * ori_left_wrist() const
Get ori_left_wrist value.
Definition: HumanSkeletonInterface.cpp:3366
fawkes::HumanSkeletonInterface::maxlenof_pos_right_fingertip_confidence
size_t maxlenof_pos_right_fingertip_confidence() const
Get maximum length of pos_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1904
fawkes::HumanSkeletonInterface::pos_left_knee
float * pos_left_knee() const
Get pos_left_knee value.
Definition: HumanSkeletonInterface.cpp:2024
fawkes::HumanSkeletonInterface::set_pos_right_fingertip_confidence
void set_pos_right_fingertip_confidence(const float new_pos_right_fingertip_confidence)
Set pos_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1915
fawkes::HumanSkeletonInterface::set_ori_right_elbow_confidence
void set_ori_right_elbow_confidence(const float new_ori_right_elbow_confidence)
Set ori_right_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3936
fawkes::HumanSkeletonInterface::pos_right_hip
float * pos_right_hip() const
Get pos_right_hip value.
Definition: HumanSkeletonInterface.cpp:2315
fawkes::HumanSkeletonInterface::set_pos_right_ankle
void set_pos_right_ankle(unsigned int index, const float new_pos_right_ankle)
Set pos_right_ankle value at given index.
Definition: HumanSkeletonInterface.cpp:2559
fawkes::HumanSkeletonInterface::ori_head_confidence
float ori_head_confidence() const
Get ori_head_confidence value.
Definition: HumanSkeletonInterface.cpp:2763
fawkes::HumanSkeletonInterface::set_ori_right_hand_confidence
void set_ori_right_hand_confidence(const float new_ori_right_hand_confidence)
Set ori_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:4130
fawkes::HumanSkeletonInterface::pos_left_elbow
float * pos_left_elbow() const
Get pos_left_elbow value.
Definition: HumanSkeletonInterface.cpp:957
fawkes::HumanSkeletonInterface::maxlenof_ori_right_shoulder_confidence
size_t maxlenof_ori_right_shoulder_confidence() const
Get maximum length of ori_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:3828
fawkes::HumanSkeletonInterface::ori_torso
float * ori_torso() const
Get ori_torso value.
Definition: HumanSkeletonInterface.cpp:2888
fawkes::HumanSkeletonInterface::maxlenof_pos_left_ankle
size_t maxlenof_pos_left_ankle() const
Get maximum length of pos_left_ankle value.
Definition: HumanSkeletonInterface.cpp:2147
fawkes::HumanSkeletonInterface::set_pos_right_shoulder_confidence
void set_pos_right_shoulder_confidence(const float new_pos_right_shoulder_confidence)
Set pos_right_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:1527
fawkes::HumanSkeletonInterface::set_ori_head_confidence
void set_ori_head_confidence(const float new_ori_head_confidence)
Set ori_head_confidence value.
Definition: HumanSkeletonInterface.cpp:2784
fawkes::HumanSkeletonInterface::ori_waist_confidence
float ori_waist_confidence() const
Get ori_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:3042
fawkes::HumanSkeletonInterface::maxlenof_ori_left_knee_confidence
size_t maxlenof_ori_left_knee_confidence() const
Get maximum length of ori_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4410
fawkes::HumanSkeletonInterface::set_ori_right_elbow
void set_ori_right_elbow(unsigned int index, const float new_ori_right_elbow)
Set ori_right_elbow value at given index.
Definition: HumanSkeletonInterface.cpp:3901
fawkes::HumanSkeletonInterface::user_id
uint32_t user_id() const
Get user_id value.
Definition: HumanSkeletonInterface.cpp:224
fawkes::HumanSkeletonInterface::maxlenof_ori_left_hip
size_t maxlenof_ori_left_hip() const
Get maximum length of ori_left_hip value.
Definition: HumanSkeletonInterface.cpp:4265
fawkes::HumanSkeletonInterface::set_ori_left_hip
void set_ori_left_hip(unsigned int index, const float new_ori_left_hip)
Set ori_left_hip value at given index.
Definition: HumanSkeletonInterface.cpp:4289
fawkes::HumanSkeletonInterface::enum_tostring
virtual const char * enum_tostring(const char *enumtype, int val) const
Definition: HumanSkeletonInterface.cpp:5033
fawkes::HumanSkeletonInterface::set_ori_left_foot
void set_ori_left_foot(unsigned int index, const float new_ori_left_foot)
Set ori_left_foot value at given index.
Definition: HumanSkeletonInterface.cpp:4580
fawkes::HumanSkeletonInterface::ori_left_shoulder
float * ori_left_shoulder() const
Get ori_left_shoulder value.
Definition: HumanSkeletonInterface.cpp:3172
fawkes::HumanSkeletonInterface::pos_left_foot_confidence
float pos_left_foot_confidence() const
Get pos_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:2282
fawkes::HumanSkeletonInterface::pos_right_hand
float * pos_right_hand() const
Get pos_right_hand value.
Definition: HumanSkeletonInterface.cpp:1733
fawkes::HumanSkeletonInterface::pos_neck_confidence
float pos_neck_confidence() const
Get pos_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:544
fawkes::HumanSkeletonInterface::ori_left_foot_confidence
float ori_left_foot_confidence() const
Get ori_left_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:4594
fawkes::Message::add_fieldinfo
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the info list.
Definition: message.cpp:406
fawkes::HumanSkeletonInterface::maxlenof_ori_neck
size_t maxlenof_ori_neck() const
Get maximum length of ori_neck value.
Definition: HumanSkeletonInterface.cpp:2820
fawkes::HumanSkeletonInterface::maxlenof_pos_left_wrist_confidence
size_t maxlenof_pos_left_wrist_confidence() const
Get maximum length of pos_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1128
fawkes::HumanSkeletonInterface::ori_head
float * ori_head() const
Get ori_head value.
Definition: HumanSkeletonInterface.cpp:2702
fawkes::HumanSkeletonInterface::maxlenof_ori_left_wrist
size_t maxlenof_ori_left_wrist() const
Get maximum length of ori_left_wrist value.
Definition: HumanSkeletonInterface.cpp:3392
fawkes::HumanSkeletonInterface::pose
char * pose() const
Get pose value.
Definition: HumanSkeletonInterface.cpp:298
fawkes::HumanSkeletonInterface::maxlenof_ori_right_ankle_confidence
size_t maxlenof_ori_right_ankle_confidence() const
Get maximum length of ori_right_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4895
fawkes::HumanSkeletonInterface::maxlenof_ori_right_ankle
size_t maxlenof_ori_right_ankle() const
Get maximum length of ori_right_ankle value.
Definition: HumanSkeletonInterface.cpp:4847
fawkes::HumanSkeletonInterface::pos_right_ankle
float * pos_right_ankle() const
Get pos_right_ankle value.
Definition: HumanSkeletonInterface.cpp:2509
fawkes::HumanSkeletonInterface::set_pos_left_knee
void set_pos_left_knee(unsigned int index, const float new_pos_left_knee)
Set pos_left_knee value at given index.
Definition: HumanSkeletonInterface.cpp:2074
fawkes::HumanSkeletonInterface::set_pos_right_fingertip
void set_pos_right_fingertip(unsigned int index, const float new_pos_right_fingertip)
Set pos_right_fingertip value at given index.
Definition: HumanSkeletonInterface.cpp:1880
fawkes::HumanSkeletonInterface::set_pos_right_hip
void set_pos_right_hip(unsigned int index, const float new_pos_right_hip)
Set pos_right_hip value at given index.
Definition: HumanSkeletonInterface.cpp:2365
fawkes::HumanSkeletonInterface::maxlenof_ori_torso_confidence
size_t maxlenof_ori_torso_confidence() const
Get maximum length of ori_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:2959
fawkes::HumanSkeletonInterface::set_pos_left_knee_confidence
void set_pos_left_knee_confidence(const float new_pos_left_knee_confidence)
Set pos_left_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2109
fawkes::HumanSkeletonInterface::ori_left_collar
float * ori_left_collar() const
Get ori_left_collar value.
Definition: HumanSkeletonInterface.cpp:3075
fawkes::HumanSkeletonInterface::maxlenof_ori_right_wrist_confidence
size_t maxlenof_ori_right_wrist_confidence() const
Get maximum length of ori_right_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:4022
fawkes::HumanSkeletonInterface::pos_left_fingertip_confidence
float pos_left_fingertip_confidence() const
Get pos_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:1312
fawkes::HumanSkeletonInterface::maxlenof_ori_left_shoulder
size_t maxlenof_ori_left_shoulder() const
Get maximum length of ori_left_shoulder value.
Definition: HumanSkeletonInterface.cpp:3198
fawkes::HumanSkeletonInterface::pos_left_shoulder_confidence
float pos_left_shoulder_confidence() const
Get pos_left_shoulder_confidence value.
Definition: HumanSkeletonInterface.cpp:924
fawkes::HumanSkeletonInterface::ori_left_fingertip_confidence
float ori_left_fingertip_confidence() const
Get ori_left_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:3624
fawkes::HumanSkeletonInterface::ori_right_shoulder
float * ori_right_shoulder() const
Get ori_right_shoulder value.
Definition: HumanSkeletonInterface.cpp:3754
fawkes::HumanSkeletonInterface::ori_right_fingertip_confidence
float ori_right_fingertip_confidence() const
Get ori_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:4206
fawkes::HumanSkeletonInterface::set_pos_left_collar_confidence
void set_pos_left_collar_confidence(const float new_pos_left_collar_confidence)
Set pos_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:848
fawkes::HumanSkeletonInterface::set_pos_waist_confidence
void set_pos_waist_confidence(const float new_pos_waist_confidence)
Set pos_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:751
fawkes::HumanSkeletonInterface::maxlenof_ori_left_foot
size_t maxlenof_ori_left_foot() const
Get maximum length of ori_left_foot value.
Definition: HumanSkeletonInterface.cpp:4556
fawkes::HumanSkeletonInterface::pos_left_shoulder
float * pos_left_shoulder() const
Get pos_left_shoulder value.
Definition: HumanSkeletonInterface.cpp:860
fawkes::HumanSkeletonInterface::maxlenof_com
size_t maxlenof_com() const
Get maximum length of com value.
Definition: HumanSkeletonInterface.cpp:355
fawkes::HumanSkeletonInterface::maxlenof_ori_right_foot
size_t maxlenof_ori_right_foot() const
Get maximum length of ori_right_foot value.
Definition: HumanSkeletonInterface.cpp:4944
fawkes::HumanSkeletonInterface::pos_neck
float * pos_neck() const
Get pos_neck value.
Definition: HumanSkeletonInterface.cpp:483
fawkes::HumanSkeletonInterface::maxlenof_pos_right_hand
size_t maxlenof_pos_right_hand() const
Get maximum length of pos_right_hand value.
Definition: HumanSkeletonInterface.cpp:1759
fawkes::HumanSkeletonInterface::ori_right_elbow
float * ori_right_elbow() const
Get ori_right_elbow value.
Definition: HumanSkeletonInterface.cpp:3851
fawkes::HumanSkeletonInterface::maxlenof_pos_left_knee
size_t maxlenof_pos_left_knee() const
Get maximum length of pos_left_knee value.
Definition: HumanSkeletonInterface.cpp:2050
fawkes::HumanSkeletonInterface::maxlenof_pos_head
size_t maxlenof_pos_head() const
Get maximum length of pos_head value.
Definition: HumanSkeletonInterface.cpp:415
fawkes::HumanSkeletonInterface::maxlenof_pos_right_foot
size_t maxlenof_pos_right_foot() const
Get maximum length of pos_right_foot value.
Definition: HumanSkeletonInterface.cpp:2632
fawkes::HumanSkeletonInterface::maxlenof_user_id
size_t maxlenof_user_id() const
Get maximum length of user_id value.
Definition: HumanSkeletonInterface.cpp:234
fawkes::HumanSkeletonInterface::maxlenof_ori_neck_confidence
size_t maxlenof_ori_neck_confidence() const
Get maximum length of ori_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:2866
fawkes::IFT_STRING
@ IFT_STRING
string field
Definition: types.h:62
fawkes::HumanSkeletonInterface::set_ori_waist
void set_ori_waist(unsigned int index, const float new_ori_waist)
Set ori_waist value at given index.
Definition: HumanSkeletonInterface.cpp:3028
fawkes::HumanSkeletonInterface::maxlenof_ori_head
size_t maxlenof_ori_head() const
Get maximum length of ori_head value.
Definition: HumanSkeletonInterface.cpp:2727
fawkes::HumanSkeletonInterface::pos_right_wrist
float * pos_right_wrist() const
Get pos_right_wrist value.
Definition: HumanSkeletonInterface.cpp:1636
fawkes::HumanSkeletonInterface::ori_right_collar
float * ori_right_collar() const
Get ori_right_collar value.
Definition: HumanSkeletonInterface.cpp:3657
fawkes::HumanSkeletonInterface::pos_right_hand_confidence
float pos_right_hand_confidence() const
Get pos_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1797
fawkes::HumanSkeletonInterface::ori_left_elbow_confidence
float ori_left_elbow_confidence() const
Get ori_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3333
fawkes::HumanSkeletonInterface::set_pos_torso
void set_pos_torso(unsigned int index, const float new_pos_torso)
Set pos_torso value at given index.
Definition: HumanSkeletonInterface.cpp:623
fawkes::HumanSkeletonInterface::ori_left_ankle_confidence
float ori_left_ankle_confidence() const
Get ori_left_ankle_confidence value.
Definition: HumanSkeletonInterface.cpp:4497
fawkes::HumanSkeletonInterface::set_pos_left_wrist_confidence
void set_pos_left_wrist_confidence(const float new_pos_left_wrist_confidence)
Set pos_left_wrist_confidence value.
Definition: HumanSkeletonInterface.cpp:1139
fawkes::HumanSkeletonInterface::ori_left_ankle
float * ori_left_ankle() const
Get ori_left_ankle value.
Definition: HumanSkeletonInterface.cpp:4433
fawkes::HumanSkeletonInterface::maxlenof_ori_right_fingertip_confidence
size_t maxlenof_ori_right_fingertip_confidence() const
Get maximum length of ori_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:4216
fawkes::HumanSkeletonInterface::pos_left_foot
float * pos_left_foot() const
Get pos_left_foot value.
Definition: HumanSkeletonInterface.cpp:2218
fawkes::HumanSkeletonInterface::maxlenof_ori_right_collar_confidence
size_t maxlenof_ori_right_collar_confidence() const
Get maximum length of ori_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3731
fawkes::HumanSkeletonInterface::maxlenof_ori_right_wrist
size_t maxlenof_ori_right_wrist() const
Get maximum length of ori_right_wrist value.
Definition: HumanSkeletonInterface.cpp:3974
fawkes::HumanSkeletonInterface::pos_right_collar
float * pos_right_collar() const
Get pos_right_collar value.
Definition: HumanSkeletonInterface.cpp:1345
fawkes::HumanSkeletonInterface::pos_left_hip_confidence
float pos_left_hip_confidence() const
Get pos_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:1991
fawkes::HumanSkeletonInterface::maxlenof_ori_right_collar
size_t maxlenof_ori_right_collar() const
Get maximum length of ori_right_collar value.
Definition: HumanSkeletonInterface.cpp:3683
fawkes::HumanSkeletonInterface::maxlenof_ori_left_hand
size_t maxlenof_ori_left_hand() const
Get maximum length of ori_left_hand value.
Definition: HumanSkeletonInterface.cpp:3489
fawkes::HumanSkeletonInterface::set_ori_neck
void set_ori_neck(unsigned int index, const float new_ori_neck)
Set ori_neck value at given index.
Definition: HumanSkeletonInterface.cpp:2842
fawkes::HumanSkeletonInterface::maxlenof_pos_torso_confidence
size_t maxlenof_pos_torso_confidence() const
Get maximum length of pos_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:647
fawkes::HumanSkeletonInterface::set_pos_right_elbow
void set_pos_right_elbow(unsigned int index, const float new_pos_right_elbow)
Set pos_right_elbow value at given index.
Definition: HumanSkeletonInterface.cpp:1589
fawkes::HumanSkeletonInterface::pos_waist
float * pos_waist() const
Get pos_waist value.
Definition: HumanSkeletonInterface.cpp:669
fawkes::HumanSkeletonInterface::pos_right_shoulder
float * pos_right_shoulder() const
Get pos_right_shoulder value.
Definition: HumanSkeletonInterface.cpp:1442
fawkes::HumanSkeletonInterface::maxlenof_pos_right_hand_confidence
size_t maxlenof_pos_right_hand_confidence() const
Get maximum length of pos_right_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1807
fawkes::HumanSkeletonInterface::maxlenof_ori_left_knee
size_t maxlenof_ori_left_knee() const
Get maximum length of ori_left_knee value.
Definition: HumanSkeletonInterface.cpp:4362
fawkes::HumanSkeletonInterface::set_pos_right_collar_confidence
void set_pos_right_collar_confidence(const float new_pos_right_collar_confidence)
Set pos_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:1430
fawkes::HumanSkeletonInterface::ori_waist
float * ori_waist() const
Get ori_waist value.
Definition: HumanSkeletonInterface.cpp:2981
fawkes::HumanSkeletonInterface::maxlenof_ori_right_fingertip
size_t maxlenof_ori_right_fingertip() const
Get maximum length of ori_right_fingertip value.
Definition: HumanSkeletonInterface.cpp:4168
fawkes::HumanSkeletonInterface::maxlenof_pos_right_collar
size_t maxlenof_pos_right_collar() const
Get maximum length of pos_right_collar value.
Definition: HumanSkeletonInterface.cpp:1371
fawkes::HumanSkeletonInterface::set_ori_left_hand_confidence
void set_ori_left_hand_confidence(const float new_ori_left_hand_confidence)
Set ori_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:3548
fawkes::HumanSkeletonInterface::maxlenof_ori_left_hip_confidence
size_t maxlenof_ori_left_hip_confidence() const
Get maximum length of ori_left_hip_confidence value.
Definition: HumanSkeletonInterface.cpp:4313
fawkes::HumanSkeletonInterface::set_pos_right_wrist
void set_pos_right_wrist(unsigned int index, const float new_pos_right_wrist)
Set pos_right_wrist value at given index.
Definition: HumanSkeletonInterface.cpp:1686
fawkes::HumanSkeletonInterface::maxlenof_pos_left_hand_confidence
size_t maxlenof_pos_left_hand_confidence() const
Get maximum length of pos_left_hand_confidence value.
Definition: HumanSkeletonInterface.cpp:1225
fawkes::HumanSkeletonInterface::set_ori_right_foot_confidence
void set_ori_right_foot_confidence(const float new_ori_right_foot_confidence)
Set ori_right_foot_confidence value.
Definition: HumanSkeletonInterface.cpp:5003
fawkes::HumanSkeletonInterface::maxlenof_ori_right_knee_confidence
size_t maxlenof_ori_right_knee_confidence() const
Get maximum length of ori_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:4798
fawkes::HumanSkeletonInterface::maxlenof_ori_left_collar
size_t maxlenof_ori_left_collar() const
Get maximum length of ori_left_collar value.
Definition: HumanSkeletonInterface.cpp:3101
fawkes::HumanSkeletonInterface::set_ori_left_collar_confidence
void set_ori_left_collar_confidence(const float new_ori_left_collar_confidence)
Set ori_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3160
fawkes::HumanSkeletonInterface::State
State
Current tracking state for the skeleton.
Definition: HumanSkeletonInterface.h:56
fawkes::HumanSkeletonInterface::pos_right_collar_confidence
float pos_right_collar_confidence() const
Get pos_right_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:1409
fawkes::HumanSkeletonInterface::ori_left_foot
float * ori_left_foot() const
Get ori_left_foot value.
Definition: HumanSkeletonInterface.cpp:4530
fawkes::HumanSkeletonInterface::maxlenof_pos_left_foot
size_t maxlenof_pos_left_foot() const
Get maximum length of pos_left_foot value.
Definition: HumanSkeletonInterface.cpp:2244
fawkes::HumanSkeletonInterface::maxlenof_ori_right_knee
size_t maxlenof_ori_right_knee() const
Get maximum length of ori_right_knee value.
Definition: HumanSkeletonInterface.cpp:4750
fawkes::HumanSkeletonInterface::pos_right_knee_confidence
float pos_right_knee_confidence() const
Get pos_right_knee_confidence value.
Definition: HumanSkeletonInterface.cpp:2476
fawkes::HumanSkeletonInterface::set_ori_right_fingertip_confidence
void set_ori_right_fingertip_confidence(const float new_ori_right_fingertip_confidence)
Set ori_right_fingertip_confidence value.
Definition: HumanSkeletonInterface.cpp:4227
fawkes::HumanSkeletonInterface::set_ori_neck_confidence
void set_ori_neck_confidence(const float new_ori_neck_confidence)
Set ori_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:2877
fawkes::HumanSkeletonInterface::maxlenof_pos_waist_confidence
size_t maxlenof_pos_waist_confidence() const
Get maximum length of pos_waist_confidence value.
Definition: HumanSkeletonInterface.cpp:740
fawkes::HumanSkeletonInterface::set_pos_left_shoulder
void set_pos_left_shoulder(unsigned int index, const float new_pos_left_shoulder)
Set pos_left_shoulder value at given index.
Definition: HumanSkeletonInterface.cpp:910
fawkes::HumanSkeletonInterface::ori_neck_confidence
float ori_neck_confidence() const
Get ori_neck_confidence value.
Definition: HumanSkeletonInterface.cpp:2856
fawkes::HumanSkeletonInterface::set_ori_left_shoulder
void set_ori_left_shoulder(unsigned int index, const float new_ori_left_shoulder)
Set ori_left_shoulder value at given index.
Definition: HumanSkeletonInterface.cpp:3222
fawkes::HumanSkeletonInterface::set_ori_left_knee
void set_ori_left_knee(unsigned int index, const float new_ori_left_knee)
Set ori_left_knee value at given index.
Definition: HumanSkeletonInterface.cpp:4386
fawkes::HumanSkeletonInterface::set_ori_right_fingertip
void set_ori_right_fingertip(unsigned int index, const float new_ori_right_fingertip)
Set ori_right_fingertip value at given index.
Definition: HumanSkeletonInterface.cpp:4192
fawkes::HumanSkeletonInterface::maxlenof_ori_left_collar_confidence
size_t maxlenof_ori_left_collar_confidence() const
Get maximum length of ori_left_collar_confidence value.
Definition: HumanSkeletonInterface.cpp:3149
fawkes::HumanSkeletonInterface::maxlenof_visibility_history
size_t maxlenof_visibility_history() const
Get maximum length of visibility_history value.
Definition: HumanSkeletonInterface.cpp:271
fawkes::HumanSkeletonInterface::maxlenof_ori_left_fingertip
size_t maxlenof_ori_left_fingertip() const
Get maximum length of ori_left_fingertip value.
Definition: HumanSkeletonInterface.cpp:3586
fawkes::HumanSkeletonInterface::set_ori_left_elbow_confidence
void set_ori_left_elbow_confidence(const float new_ori_left_elbow_confidence)
Set ori_left_elbow_confidence value.
Definition: HumanSkeletonInterface.cpp:3354
fawkes::HumanSkeletonInterface::set_ori_torso_confidence
void set_ori_torso_confidence(const float new_ori_torso_confidence)
Set ori_torso_confidence value.
Definition: HumanSkeletonInterface.cpp:2970
fawkes::HumanSkeletonInterface::pos_right_fingertip
float * pos_right_fingertip() const
Get pos_right_fingertip value.
Definition: HumanSkeletonInterface.cpp:1830
fawkes::Exception
Definition: exception.h:41