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