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