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