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
33namespace fawkes {
34
35/** @class HumanSkeletonInterface <interfaces/HumanSkeletonInterface.h>
36 * HumanSkeletonInterface Fawkes BlackBoard Interface.
37 *
38
39 * @ingroup FawkesInterfaces
40 */
41
42
43
44/** Constructor */
45HumanSkeletonInterface::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 */
162HumanSkeletonInterface::~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 */
170const char *
171HumanSkeletonInterface::tostring_State(State value) const
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 */
187HumanSkeletonInterface::state() const
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 */
196size_t
197HumanSkeletonInterface::maxlenof_state() const
198{
199 return 1;
200}
201
202/** Set state value.
203 * Current state.
204 * @param new_state new state value
205 */
206void
207HumanSkeletonInterface::set_state(const State new_state)
208{
209 set_field(data->state, new_state);
210}
211
212/** Get user_id value.
213 * Tracking ID of this user.
214 * @return user_id value
215 */
216uint32_t
217HumanSkeletonInterface::user_id() const
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 */
226size_t
227HumanSkeletonInterface::maxlenof_user_id() const
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 */
236void
237HumanSkeletonInterface::set_user_id(const uint32_t new_user_id)
238{
239 set_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 */
252int32_t
253HumanSkeletonInterface::visibility_history() const
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 */
262size_t
263HumanSkeletonInterface::maxlenof_visibility_history() const
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 */
278void
279HumanSkeletonInterface::set_visibility_history(const int32_t new_visibility_history)
280{
281 set_field(data->visibility_history, new_visibility_history);
282}
283
284/** Get pose value.
285 * Detected user pose.
286 * @return pose value
287 */
288char *
289HumanSkeletonInterface::pose() const
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 */
298size_t
299HumanSkeletonInterface::maxlenof_pose() const
300{
301 return 32;
302}
303
304/** Set pose value.
305 * Detected user pose.
306 * @param new_pose new pose value
307 */
308void
309HumanSkeletonInterface::set_pose(const char * new_pose)
310{
311 set_field(data->pose, new_pose);
312}
313
314/** Get com value.
315 * Center of mass.
316 * @return com value
317 */
318float *
319HumanSkeletonInterface::com() const
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 */
330float
331HumanSkeletonInterface::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 */
343size_t
344HumanSkeletonInterface::maxlenof_com() const
345{
346 return 3;
347}
348
349/** Set com value.
350 * Center of mass.
351 * @param new_com new com value
352 */
353void
354HumanSkeletonInterface::set_com(const float * new_com)
355{
356 set_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 */
364void
365HumanSkeletonInterface::set_com(unsigned int index, const float new_com)
366{
367 set_field(data->com, index, new_com);
368}
369/** Get pos_head value.
370 * Head position vector.
371 * @return pos_head value
372 */
373float *
374HumanSkeletonInterface::pos_head() const
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 */
385float
386HumanSkeletonInterface::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 */
398size_t
399HumanSkeletonInterface::maxlenof_pos_head() const
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 */
408void
409HumanSkeletonInterface::set_pos_head(const float * new_pos_head)
410{
411 set_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 */
419void
420HumanSkeletonInterface::set_pos_head(unsigned int index, const float new_pos_head)
421{
422 set_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 */
429float
430HumanSkeletonInterface::pos_head_confidence() const
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 */
439size_t
440HumanSkeletonInterface::maxlenof_pos_head_confidence() const
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 */
450void
451HumanSkeletonInterface::set_pos_head_confidence(const float new_pos_head_confidence)
452{
453 set_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 */
460float *
461HumanSkeletonInterface::pos_neck() const
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 */
472float
473HumanSkeletonInterface::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 */
485size_t
486HumanSkeletonInterface::maxlenof_pos_neck() const
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 */
495void
496HumanSkeletonInterface::set_pos_neck(const float * new_pos_neck)
497{
498 set_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 */
506void
507HumanSkeletonInterface::set_pos_neck(unsigned int index, const float new_pos_neck)
508{
509 set_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 */
516float
517HumanSkeletonInterface::pos_neck_confidence() const
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 */
526size_t
527HumanSkeletonInterface::maxlenof_pos_neck_confidence() const
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 */
537void
538HumanSkeletonInterface::set_pos_neck_confidence(const float new_pos_neck_confidence)
539{
540 set_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 */
547float *
548HumanSkeletonInterface::pos_torso() const
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 */
559float
560HumanSkeletonInterface::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 */
572size_t
573HumanSkeletonInterface::maxlenof_pos_torso() const
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 */
582void
583HumanSkeletonInterface::set_pos_torso(const float * new_pos_torso)
584{
585 set_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 */
593void
594HumanSkeletonInterface::set_pos_torso(unsigned int index, const float new_pos_torso)
595{
596 set_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 */
603float
604HumanSkeletonInterface::pos_torso_confidence() const
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 */
613size_t
614HumanSkeletonInterface::maxlenof_pos_torso_confidence() const
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 */
624void
625HumanSkeletonInterface::set_pos_torso_confidence(const float new_pos_torso_confidence)
626{
627 set_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 */
634float *
635HumanSkeletonInterface::pos_waist() const
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 */
646float
647HumanSkeletonInterface::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 */
659size_t
660HumanSkeletonInterface::maxlenof_pos_waist() const
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 */
669void
670HumanSkeletonInterface::set_pos_waist(const float * new_pos_waist)
671{
672 set_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 */
680void
681HumanSkeletonInterface::set_pos_waist(unsigned int index, const float new_pos_waist)
682{
683 set_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 */
690float
691HumanSkeletonInterface::pos_waist_confidence() const
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 */
700size_t
701HumanSkeletonInterface::maxlenof_pos_waist_confidence() const
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 */
711void
712HumanSkeletonInterface::set_pos_waist_confidence(const float new_pos_waist_confidence)
713{
714 set_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 */
722float *
723HumanSkeletonInterface::pos_left_collar() const
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 */
735float
736HumanSkeletonInterface::pos_left_collar(unsigned int index) const
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 */
748size_t
749HumanSkeletonInterface::maxlenof_pos_left_collar() const
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 */
759void
760HumanSkeletonInterface::set_pos_left_collar(const float * new_pos_left_collar)
761{
762 set_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 */
771void
772HumanSkeletonInterface::set_pos_left_collar(unsigned int index, const float new_pos_left_collar)
773{
774 set_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 */
781float
782HumanSkeletonInterface::pos_left_collar_confidence() const
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 */
791size_t
792HumanSkeletonInterface::maxlenof_pos_left_collar_confidence() const
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 */
802void
803HumanSkeletonInterface::set_pos_left_collar_confidence(const float new_pos_left_collar_confidence)
804{
805 set_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 */
813float *
814HumanSkeletonInterface::pos_left_shoulder() const
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 */
826float
827HumanSkeletonInterface::pos_left_shoulder(unsigned int index) const
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 */
839size_t
840HumanSkeletonInterface::maxlenof_pos_left_shoulder() const
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 */
850void
851HumanSkeletonInterface::set_pos_left_shoulder(const float * new_pos_left_shoulder)
852{
853 set_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 */
862void
863HumanSkeletonInterface::set_pos_left_shoulder(unsigned int index, const float new_pos_left_shoulder)
864{
865 set_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 */
872float
873HumanSkeletonInterface::pos_left_shoulder_confidence() const
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 */
882size_t
883HumanSkeletonInterface::maxlenof_pos_left_shoulder_confidence() const
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 */
893void
894HumanSkeletonInterface::set_pos_left_shoulder_confidence(const float new_pos_left_shoulder_confidence)
895{
896 set_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 */
904float *
905HumanSkeletonInterface::pos_left_elbow() const
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 */
917float
918HumanSkeletonInterface::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 */
930size_t
931HumanSkeletonInterface::maxlenof_pos_left_elbow() const
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 */
941void
942HumanSkeletonInterface::set_pos_left_elbow(const float * new_pos_left_elbow)
943{
944 set_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 */
953void
954HumanSkeletonInterface::set_pos_left_elbow(unsigned int index, const float new_pos_left_elbow)
955{
956 set_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 */
963float
964HumanSkeletonInterface::pos_left_elbow_confidence() const
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 */
973size_t
974HumanSkeletonInterface::maxlenof_pos_left_elbow_confidence() const
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 */
984void
985HumanSkeletonInterface::set_pos_left_elbow_confidence(const float new_pos_left_elbow_confidence)
986{
987 set_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 */
995float *
996HumanSkeletonInterface::pos_left_wrist() const
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 */
1008float
1009HumanSkeletonInterface::pos_left_wrist(unsigned int index) const
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 */
1021size_t
1022HumanSkeletonInterface::maxlenof_pos_left_wrist() const
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 */
1032void
1033HumanSkeletonInterface::set_pos_left_wrist(const float * new_pos_left_wrist)
1034{
1035 set_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 */
1044void
1045HumanSkeletonInterface::set_pos_left_wrist(unsigned int index, const float new_pos_left_wrist)
1046{
1047 set_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 */
1054float
1055HumanSkeletonInterface::pos_left_wrist_confidence() const
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 */
1064size_t
1065HumanSkeletonInterface::maxlenof_pos_left_wrist_confidence() const
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 */
1075void
1076HumanSkeletonInterface::set_pos_left_wrist_confidence(const float new_pos_left_wrist_confidence)
1077{
1078 set_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 */
1086float *
1087HumanSkeletonInterface::pos_left_hand() const
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 */
1099float
1100HumanSkeletonInterface::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 */
1112size_t
1113HumanSkeletonInterface::maxlenof_pos_left_hand() const
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 */
1123void
1124HumanSkeletonInterface::set_pos_left_hand(const float * new_pos_left_hand)
1125{
1126 set_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 */
1135void
1136HumanSkeletonInterface::set_pos_left_hand(unsigned int index, const float new_pos_left_hand)
1137{
1138 set_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 */
1145float
1146HumanSkeletonInterface::pos_left_hand_confidence() const
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 */
1155size_t
1156HumanSkeletonInterface::maxlenof_pos_left_hand_confidence() const
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 */
1166void
1167HumanSkeletonInterface::set_pos_left_hand_confidence(const float new_pos_left_hand_confidence)
1168{
1169 set_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 */
1177float *
1178HumanSkeletonInterface::pos_left_fingertip() const
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 */
1190float
1191HumanSkeletonInterface::pos_left_fingertip(unsigned int index) const
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 */
1203size_t
1204HumanSkeletonInterface::maxlenof_pos_left_fingertip() const
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 */
1214void
1215HumanSkeletonInterface::set_pos_left_fingertip(const float * new_pos_left_fingertip)
1216{
1217 set_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 */
1226void
1227HumanSkeletonInterface::set_pos_left_fingertip(unsigned int index, const float new_pos_left_fingertip)
1228{
1229 set_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 */
1236float
1237HumanSkeletonInterface::pos_left_fingertip_confidence() const
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 */
1246size_t
1247HumanSkeletonInterface::maxlenof_pos_left_fingertip_confidence() const
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 */
1257void
1258HumanSkeletonInterface::set_pos_left_fingertip_confidence(const float new_pos_left_fingertip_confidence)
1259{
1260 set_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 */
1268float *
1269HumanSkeletonInterface::pos_right_collar() const
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 */
1281float
1282HumanSkeletonInterface::pos_right_collar(unsigned int index) const
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 */
1294size_t
1295HumanSkeletonInterface::maxlenof_pos_right_collar() const
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 */
1305void
1306HumanSkeletonInterface::set_pos_right_collar(const float * new_pos_right_collar)
1307{
1308 set_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 */
1317void
1318HumanSkeletonInterface::set_pos_right_collar(unsigned int index, const float new_pos_right_collar)
1319{
1320 set_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 */
1327float
1328HumanSkeletonInterface::pos_right_collar_confidence() const
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 */
1337size_t
1338HumanSkeletonInterface::maxlenof_pos_right_collar_confidence() const
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 */
1348void
1349HumanSkeletonInterface::set_pos_right_collar_confidence(const float new_pos_right_collar_confidence)
1350{
1351 set_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 */
1359float *
1360HumanSkeletonInterface::pos_right_shoulder() const
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 */
1372float
1373HumanSkeletonInterface::pos_right_shoulder(unsigned int index) const
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 */
1385size_t
1386HumanSkeletonInterface::maxlenof_pos_right_shoulder() const
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 */
1396void
1397HumanSkeletonInterface::set_pos_right_shoulder(const float * new_pos_right_shoulder)
1398{
1399 set_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 */
1408void
1409HumanSkeletonInterface::set_pos_right_shoulder(unsigned int index, const float new_pos_right_shoulder)
1410{
1411 set_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 */
1418float
1419HumanSkeletonInterface::pos_right_shoulder_confidence() const
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 */
1428size_t
1429HumanSkeletonInterface::maxlenof_pos_right_shoulder_confidence() const
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 */
1439void
1440HumanSkeletonInterface::set_pos_right_shoulder_confidence(const float new_pos_right_shoulder_confidence)
1441{
1442 set_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 */
1450float *
1451HumanSkeletonInterface::pos_right_elbow() const
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 */
1463float
1464HumanSkeletonInterface::pos_right_elbow(unsigned int index) const
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 */
1476size_t
1477HumanSkeletonInterface::maxlenof_pos_right_elbow() const
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 */
1487void
1488HumanSkeletonInterface::set_pos_right_elbow(const float * new_pos_right_elbow)
1489{
1490 set_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 */
1499void
1500HumanSkeletonInterface::set_pos_right_elbow(unsigned int index, const float new_pos_right_elbow)
1501{
1502 set_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 */
1509float
1510HumanSkeletonInterface::pos_right_elbow_confidence() const
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 */
1519size_t
1520HumanSkeletonInterface::maxlenof_pos_right_elbow_confidence() const
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 */
1530void
1531HumanSkeletonInterface::set_pos_right_elbow_confidence(const float new_pos_right_elbow_confidence)
1532{
1533 set_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 */
1541float *
1542HumanSkeletonInterface::pos_right_wrist() const
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 */
1554float
1555HumanSkeletonInterface::pos_right_wrist(unsigned int index) const
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 */
1567size_t
1568HumanSkeletonInterface::maxlenof_pos_right_wrist() const
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 */
1578void
1579HumanSkeletonInterface::set_pos_right_wrist(const float * new_pos_right_wrist)
1580{
1581 set_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 */
1590void
1591HumanSkeletonInterface::set_pos_right_wrist(unsigned int index, const float new_pos_right_wrist)
1592{
1593 set_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 */
1600float
1601HumanSkeletonInterface::pos_right_wrist_confidence() const
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 */
1610size_t
1611HumanSkeletonInterface::maxlenof_pos_right_wrist_confidence() const
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 */
1621void
1622HumanSkeletonInterface::set_pos_right_wrist_confidence(const float new_pos_right_wrist_confidence)
1623{
1624 set_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 */
1632float *
1633HumanSkeletonInterface::pos_right_hand() const
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 */
1645float
1646HumanSkeletonInterface::pos_right_hand(unsigned int index) const
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 */
1658size_t
1659HumanSkeletonInterface::maxlenof_pos_right_hand() const
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 */
1669void
1670HumanSkeletonInterface::set_pos_right_hand(const float * new_pos_right_hand)
1671{
1672 set_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 */
1681void
1682HumanSkeletonInterface::set_pos_right_hand(unsigned int index, const float new_pos_right_hand)
1683{
1684 set_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 */
1691float
1692HumanSkeletonInterface::pos_right_hand_confidence() const
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 */
1701size_t
1702HumanSkeletonInterface::maxlenof_pos_right_hand_confidence() const
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 */
1712void
1713HumanSkeletonInterface::set_pos_right_hand_confidence(const float new_pos_right_hand_confidence)
1714{
1715 set_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 */
1723float *
1724HumanSkeletonInterface::pos_right_fingertip() const
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 */
1736float
1737HumanSkeletonInterface::pos_right_fingertip(unsigned int index) const
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 */
1749size_t
1750HumanSkeletonInterface::maxlenof_pos_right_fingertip() const
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 */
1760void
1761HumanSkeletonInterface::set_pos_right_fingertip(const float * new_pos_right_fingertip)
1762{
1763 set_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 */
1772void
1773HumanSkeletonInterface::set_pos_right_fingertip(unsigned int index, const float new_pos_right_fingertip)
1774{
1775 set_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 */
1782float
1783HumanSkeletonInterface::pos_right_fingertip_confidence() const
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 */
1792size_t
1793HumanSkeletonInterface::maxlenof_pos_right_fingertip_confidence() const
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 */
1803void
1804HumanSkeletonInterface::set_pos_right_fingertip_confidence(const float new_pos_right_fingertip_confidence)
1805{
1806 set_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 */
1814float *
1815HumanSkeletonInterface::pos_left_hip() const
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 */
1827float
1828HumanSkeletonInterface::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 */
1840size_t
1841HumanSkeletonInterface::maxlenof_pos_left_hip() const
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 */
1851void
1852HumanSkeletonInterface::set_pos_left_hip(const float * new_pos_left_hip)
1853{
1854 set_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 */
1863void
1864HumanSkeletonInterface::set_pos_left_hip(unsigned int index, const float new_pos_left_hip)
1865{
1866 set_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 */
1873float
1874HumanSkeletonInterface::pos_left_hip_confidence() const
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 */
1883size_t
1884HumanSkeletonInterface::maxlenof_pos_left_hip_confidence() const
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 */
1894void
1895HumanSkeletonInterface::set_pos_left_hip_confidence(const float new_pos_left_hip_confidence)
1896{
1897 set_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 */
1905float *
1906HumanSkeletonInterface::pos_left_knee() const
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 */
1918float
1919HumanSkeletonInterface::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 */
1931size_t
1932HumanSkeletonInterface::maxlenof_pos_left_knee() const
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 */
1942void
1943HumanSkeletonInterface::set_pos_left_knee(const float * new_pos_left_knee)
1944{
1945 set_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 */
1954void
1955HumanSkeletonInterface::set_pos_left_knee(unsigned int index, const float new_pos_left_knee)
1956{
1957 set_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 */
1964float
1965HumanSkeletonInterface::pos_left_knee_confidence() const
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 */
1974size_t
1975HumanSkeletonInterface::maxlenof_pos_left_knee_confidence() const
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 */
1985void
1986HumanSkeletonInterface::set_pos_left_knee_confidence(const float new_pos_left_knee_confidence)
1987{
1988 set_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 */
1996float *
1997HumanSkeletonInterface::pos_left_ankle() const
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 */
2009float
2010HumanSkeletonInterface::pos_left_ankle(unsigned int index) const
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 */
2022size_t
2023HumanSkeletonInterface::maxlenof_pos_left_ankle() const
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 */
2033void
2034HumanSkeletonInterface::set_pos_left_ankle(const float * new_pos_left_ankle)
2035{
2036 set_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 */
2045void
2046HumanSkeletonInterface::set_pos_left_ankle(unsigned int index, const float new_pos_left_ankle)
2047{
2048 set_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 */
2055float
2056HumanSkeletonInterface::pos_left_ankle_confidence() const
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 */
2065size_t
2066HumanSkeletonInterface::maxlenof_pos_left_ankle_confidence() const
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 */
2076void
2077HumanSkeletonInterface::set_pos_left_ankle_confidence(const float new_pos_left_ankle_confidence)
2078{
2079 set_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 */
2087float *
2088HumanSkeletonInterface::pos_left_foot() const
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 */
2100float
2101HumanSkeletonInterface::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 */
2113size_t
2114HumanSkeletonInterface::maxlenof_pos_left_foot() const
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 */
2124void
2125HumanSkeletonInterface::set_pos_left_foot(const float * new_pos_left_foot)
2126{
2127 set_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 */
2136void
2137HumanSkeletonInterface::set_pos_left_foot(unsigned int index, const float new_pos_left_foot)
2138{
2139 set_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 */
2146float
2147HumanSkeletonInterface::pos_left_foot_confidence() const
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 */
2156size_t
2157HumanSkeletonInterface::maxlenof_pos_left_foot_confidence() const
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 */
2167void
2168HumanSkeletonInterface::set_pos_left_foot_confidence(const float new_pos_left_foot_confidence)
2169{
2170 set_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 */
2178float *
2179HumanSkeletonInterface::pos_right_hip() const
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 */
2191float
2192HumanSkeletonInterface::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 */
2204size_t
2205HumanSkeletonInterface::maxlenof_pos_right_hip() const
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 */
2215void
2216HumanSkeletonInterface::set_pos_right_hip(const float * new_pos_right_hip)
2217{
2218 set_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 */
2227void
2228HumanSkeletonInterface::set_pos_right_hip(unsigned int index, const float new_pos_right_hip)
2229{
2230 set_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 */
2237float
2238HumanSkeletonInterface::pos_right_hip_confidence() const
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 */
2247size_t
2248HumanSkeletonInterface::maxlenof_pos_right_hip_confidence() const
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 */
2258void
2259HumanSkeletonInterface::set_pos_right_hip_confidence(const float new_pos_right_hip_confidence)
2260{
2261 set_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 */
2269float *
2270HumanSkeletonInterface::pos_right_knee() const
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 */
2282float
2283HumanSkeletonInterface::pos_right_knee(unsigned int index) const
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 */
2295size_t
2296HumanSkeletonInterface::maxlenof_pos_right_knee() const
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 */
2306void
2307HumanSkeletonInterface::set_pos_right_knee(const float * new_pos_right_knee)
2308{
2309 set_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 */
2318void
2319HumanSkeletonInterface::set_pos_right_knee(unsigned int index, const float new_pos_right_knee)
2320{
2321 set_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 */
2328float
2329HumanSkeletonInterface::pos_right_knee_confidence() const
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 */
2338size_t
2339HumanSkeletonInterface::maxlenof_pos_right_knee_confidence() const
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 */
2349void
2350HumanSkeletonInterface::set_pos_right_knee_confidence(const float new_pos_right_knee_confidence)
2351{
2352 set_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 */
2360float *
2361HumanSkeletonInterface::pos_right_ankle() const
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 */
2373float
2374HumanSkeletonInterface::pos_right_ankle(unsigned int index) const
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 */
2386size_t
2387HumanSkeletonInterface::maxlenof_pos_right_ankle() const
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 */
2397void
2398HumanSkeletonInterface::set_pos_right_ankle(const float * new_pos_right_ankle)
2399{
2400 set_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 */
2409void
2410HumanSkeletonInterface::set_pos_right_ankle(unsigned int index, const float new_pos_right_ankle)
2411{
2412 set_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 */
2419float
2420HumanSkeletonInterface::pos_right_ankle_confidence() const
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 */
2429size_t
2430HumanSkeletonInterface::maxlenof_pos_right_ankle_confidence() const
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 */
2440void
2441HumanSkeletonInterface::set_pos_right_ankle_confidence(const float new_pos_right_ankle_confidence)
2442{
2443 set_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 */
2451float *
2452HumanSkeletonInterface::pos_right_foot() const
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 */
2464float
2465HumanSkeletonInterface::pos_right_foot(unsigned int index) const
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 */
2477size_t
2478HumanSkeletonInterface::maxlenof_pos_right_foot() const
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 */
2488void
2489HumanSkeletonInterface::set_pos_right_foot(const float * new_pos_right_foot)
2490{
2491 set_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 */
2500void
2501HumanSkeletonInterface::set_pos_right_foot(unsigned int index, const float new_pos_right_foot)
2502{
2503 set_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 */
2510float
2511HumanSkeletonInterface::pos_right_foot_confidence() const
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 */
2520size_t
2521HumanSkeletonInterface::maxlenof_pos_right_foot_confidence() const
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 */
2531void
2532HumanSkeletonInterface::set_pos_right_foot_confidence(const float new_pos_right_foot_confidence)
2533{
2534 set_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 */
2541float *
2542HumanSkeletonInterface::ori_head() const
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 */
2553float
2554HumanSkeletonInterface::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 */
2566size_t
2567HumanSkeletonInterface::maxlenof_ori_head() const
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 */
2576void
2577HumanSkeletonInterface::set_ori_head(const float * new_ori_head)
2578{
2579 set_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 */
2587void
2588HumanSkeletonInterface::set_ori_head(unsigned int index, const float new_ori_head)
2589{
2590 set_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 */
2597float
2598HumanSkeletonInterface::ori_head_confidence() const
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 */
2607size_t
2608HumanSkeletonInterface::maxlenof_ori_head_confidence() const
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 */
2618void
2619HumanSkeletonInterface::set_ori_head_confidence(const float new_ori_head_confidence)
2620{
2621 set_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 */
2628float *
2629HumanSkeletonInterface::ori_neck() const
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 */
2640float
2641HumanSkeletonInterface::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 */
2653size_t
2654HumanSkeletonInterface::maxlenof_ori_neck() const
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 */
2663void
2664HumanSkeletonInterface::set_ori_neck(const float * new_ori_neck)
2665{
2666 set_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 */
2674void
2675HumanSkeletonInterface::set_ori_neck(unsigned int index, const float new_ori_neck)
2676{
2677 set_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 */
2684float
2685HumanSkeletonInterface::ori_neck_confidence() const
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 */
2694size_t
2695HumanSkeletonInterface::maxlenof_ori_neck_confidence() const
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 */
2705void
2706HumanSkeletonInterface::set_ori_neck_confidence(const float new_ori_neck_confidence)
2707{
2708 set_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 */
2715float *
2716HumanSkeletonInterface::ori_torso() const
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 */
2727float
2728HumanSkeletonInterface::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 */
2740size_t
2741HumanSkeletonInterface::maxlenof_ori_torso() const
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 */
2750void
2751HumanSkeletonInterface::set_ori_torso(const float * new_ori_torso)
2752{
2753 set_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 */
2761void
2762HumanSkeletonInterface::set_ori_torso(unsigned int index, const float new_ori_torso)
2763{
2764 set_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 */
2771float
2772HumanSkeletonInterface::ori_torso_confidence() const
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 */
2781size_t
2782HumanSkeletonInterface::maxlenof_ori_torso_confidence() const
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 */
2792void
2793HumanSkeletonInterface::set_ori_torso_confidence(const float new_ori_torso_confidence)
2794{
2795 set_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 */
2802float *
2803HumanSkeletonInterface::ori_waist() const
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 */
2814float
2815HumanSkeletonInterface::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 */
2827size_t
2828HumanSkeletonInterface::maxlenof_ori_waist() const
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 */
2837void
2838HumanSkeletonInterface::set_ori_waist(const float * new_ori_waist)
2839{
2840 set_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 */
2848void
2849HumanSkeletonInterface::set_ori_waist(unsigned int index, const float new_ori_waist)
2850{
2851 set_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 */
2858float
2859HumanSkeletonInterface::ori_waist_confidence() const
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 */
2868size_t
2869HumanSkeletonInterface::maxlenof_ori_waist_confidence() const
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 */
2879void
2880HumanSkeletonInterface::set_ori_waist_confidence(const float new_ori_waist_confidence)
2881{
2882 set_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 */
2890float *
2891HumanSkeletonInterface::ori_left_collar() const
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 */
2903float
2904HumanSkeletonInterface::ori_left_collar(unsigned int index) const
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 */
2916size_t
2917HumanSkeletonInterface::maxlenof_ori_left_collar() const
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 */
2927void
2928HumanSkeletonInterface::set_ori_left_collar(const float * new_ori_left_collar)
2929{
2930 set_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 */
2939void
2940HumanSkeletonInterface::set_ori_left_collar(unsigned int index, const float new_ori_left_collar)
2941{
2942 set_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 */
2949float
2950HumanSkeletonInterface::ori_left_collar_confidence() const
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 */
2959size_t
2960HumanSkeletonInterface::maxlenof_ori_left_collar_confidence() const
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 */
2970void
2971HumanSkeletonInterface::set_ori_left_collar_confidence(const float new_ori_left_collar_confidence)
2972{
2973 set_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 */
2981float *
2982HumanSkeletonInterface::ori_left_shoulder() const
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 */
2994float
2995HumanSkeletonInterface::ori_left_shoulder(unsigned int index) const
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 */
3007size_t
3008HumanSkeletonInterface::maxlenof_ori_left_shoulder() const
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 */
3018void
3019HumanSkeletonInterface::set_ori_left_shoulder(const float * new_ori_left_shoulder)
3020{
3021 set_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 */
3030void
3031HumanSkeletonInterface::set_ori_left_shoulder(unsigned int index, const float new_ori_left_shoulder)
3032{
3033 set_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 */
3040float
3041HumanSkeletonInterface::ori_left_shoulder_confidence() const
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 */
3050size_t
3051HumanSkeletonInterface::maxlenof_ori_left_shoulder_confidence() const
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 */
3061void
3062HumanSkeletonInterface::set_ori_left_shoulder_confidence(const float new_ori_left_shoulder_confidence)
3063{
3064 set_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 */
3072float *
3073HumanSkeletonInterface::ori_left_elbow() const
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 */
3085float
3086HumanSkeletonInterface::ori_left_elbow(unsigned int index) const
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 */
3098size_t
3099HumanSkeletonInterface::maxlenof_ori_left_elbow() const
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 */
3109void
3110HumanSkeletonInterface::set_ori_left_elbow(const float * new_ori_left_elbow)
3111{
3112 set_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 */
3121void
3122HumanSkeletonInterface::set_ori_left_elbow(unsigned int index, const float new_ori_left_elbow)
3123{
3124 set_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 */
3131float
3132HumanSkeletonInterface::ori_left_elbow_confidence() const
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 */
3141size_t
3142HumanSkeletonInterface::maxlenof_ori_left_elbow_confidence() const
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 */
3152void
3153HumanSkeletonInterface::set_ori_left_elbow_confidence(const float new_ori_left_elbow_confidence)
3154{
3155 set_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 */
3163float *
3164HumanSkeletonInterface::ori_left_wrist() const
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 */
3176float
3177HumanSkeletonInterface::ori_left_wrist(unsigned int index) const
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 */
3189size_t
3190HumanSkeletonInterface::maxlenof_ori_left_wrist() const
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 */
3200void
3201HumanSkeletonInterface::set_ori_left_wrist(const float * new_ori_left_wrist)
3202{
3203 set_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 */
3212void
3213HumanSkeletonInterface::set_ori_left_wrist(unsigned int index, const float new_ori_left_wrist)
3214{
3215 set_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 */
3222float
3223HumanSkeletonInterface::ori_left_wrist_confidence() const
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 */
3232size_t
3233HumanSkeletonInterface::maxlenof_ori_left_wrist_confidence() const
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 */
3243void
3244HumanSkeletonInterface::set_ori_left_wrist_confidence(const float new_ori_left_wrist_confidence)
3245{
3246 set_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 */
3254float *
3255HumanSkeletonInterface::ori_left_hand() const
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 */
3267float
3268HumanSkeletonInterface::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 */
3280size_t
3281HumanSkeletonInterface::maxlenof_ori_left_hand() const
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 */
3291void
3292HumanSkeletonInterface::set_ori_left_hand(const float * new_ori_left_hand)
3293{
3294 set_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 */
3303void
3304HumanSkeletonInterface::set_ori_left_hand(unsigned int index, const float new_ori_left_hand)
3305{
3306 set_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 */
3313float
3314HumanSkeletonInterface::ori_left_hand_confidence() const
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 */
3323size_t
3324HumanSkeletonInterface::maxlenof_ori_left_hand_confidence() const
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 */
3334void
3335HumanSkeletonInterface::set_ori_left_hand_confidence(const float new_ori_left_hand_confidence)
3336{
3337 set_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 */
3345float *
3346HumanSkeletonInterface::ori_left_fingertip() const
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 */
3358float
3359HumanSkeletonInterface::ori_left_fingertip(unsigned int index) const
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 */
3371size_t
3372HumanSkeletonInterface::maxlenof_ori_left_fingertip() const
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 */
3382void
3383HumanSkeletonInterface::set_ori_left_fingertip(const float * new_ori_left_fingertip)
3384{
3385 set_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 */
3394void
3395HumanSkeletonInterface::set_ori_left_fingertip(unsigned int index, const float new_ori_left_fingertip)
3396{
3397 set_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 */
3404float
3405HumanSkeletonInterface::ori_left_fingertip_confidence() const
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 */
3414size_t
3415HumanSkeletonInterface::maxlenof_ori_left_fingertip_confidence() const
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 */
3425void
3426HumanSkeletonInterface::set_ori_left_fingertip_confidence(const float new_ori_left_fingertip_confidence)
3427{
3428 set_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 */
3436float *
3437HumanSkeletonInterface::ori_right_collar() const
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 */
3449float
3450HumanSkeletonInterface::ori_right_collar(unsigned int index) const
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 */
3462size_t
3463HumanSkeletonInterface::maxlenof_ori_right_collar() const
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 */
3473void
3474HumanSkeletonInterface::set_ori_right_collar(const float * new_ori_right_collar)
3475{
3476 set_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 */
3485void
3486HumanSkeletonInterface::set_ori_right_collar(unsigned int index, const float new_ori_right_collar)
3487{
3488 set_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 */
3495float
3496HumanSkeletonInterface::ori_right_collar_confidence() const
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 */
3505size_t
3506HumanSkeletonInterface::maxlenof_ori_right_collar_confidence() const
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 */
3516void
3517HumanSkeletonInterface::set_ori_right_collar_confidence(const float new_ori_right_collar_confidence)
3518{
3519 set_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 */
3527float *
3528HumanSkeletonInterface::ori_right_shoulder() const
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 */
3540float
3541HumanSkeletonInterface::ori_right_shoulder(unsigned int index) const
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 */
3553size_t
3554HumanSkeletonInterface::maxlenof_ori_right_shoulder() const
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 */
3564void
3565HumanSkeletonInterface::set_ori_right_shoulder(const float * new_ori_right_shoulder)
3566{
3567 set_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 */
3576void
3577HumanSkeletonInterface::set_ori_right_shoulder(unsigned int index, const float new_ori_right_shoulder)
3578{
3579 set_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 */
3586float
3587HumanSkeletonInterface::ori_right_shoulder_confidence() const
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 */
3596size_t
3597HumanSkeletonInterface::maxlenof_ori_right_shoulder_confidence() const
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 */
3607void
3608HumanSkeletonInterface::set_ori_right_shoulder_confidence(const float new_ori_right_shoulder_confidence)
3609{
3610 set_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 */
3618float *
3619HumanSkeletonInterface::ori_right_elbow() const
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 */
3631float
3632HumanSkeletonInterface::ori_right_elbow(unsigned int index) const
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 */
3644size_t
3645HumanSkeletonInterface::maxlenof_ori_right_elbow() const
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 */
3655void
3656HumanSkeletonInterface::set_ori_right_elbow(const float * new_ori_right_elbow)
3657{
3658 set_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 */
3667void
3668HumanSkeletonInterface::set_ori_right_elbow(unsigned int index, const float new_ori_right_elbow)
3669{
3670 set_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 */
3677float
3678HumanSkeletonInterface::ori_right_elbow_confidence() const
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 */
3687size_t
3688HumanSkeletonInterface::maxlenof_ori_right_elbow_confidence() const
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 */
3698void
3699HumanSkeletonInterface::set_ori_right_elbow_confidence(const float new_ori_right_elbow_confidence)
3700{
3701 set_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 */
3709float *
3710HumanSkeletonInterface::ori_right_wrist() const
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 */
3722float
3723HumanSkeletonInterface::ori_right_wrist(unsigned int index) const
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 */
3735size_t
3736HumanSkeletonInterface::maxlenof_ori_right_wrist() const
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 */
3746void
3747HumanSkeletonInterface::set_ori_right_wrist(const float * new_ori_right_wrist)
3748{
3749 set_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 */
3758void
3759HumanSkeletonInterface::set_ori_right_wrist(unsigned int index, const float new_ori_right_wrist)
3760{
3761 set_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 */
3768float
3769HumanSkeletonInterface::ori_right_wrist_confidence() const
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 */
3778size_t
3779HumanSkeletonInterface::maxlenof_ori_right_wrist_confidence() const
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 */
3789void
3790HumanSkeletonInterface::set_ori_right_wrist_confidence(const float new_ori_right_wrist_confidence)
3791{
3792 set_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 */
3800float *
3801HumanSkeletonInterface::ori_right_hand() const
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 */
3813float
3814HumanSkeletonInterface::ori_right_hand(unsigned int index) const
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 */
3826size_t
3827HumanSkeletonInterface::maxlenof_ori_right_hand() const
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 */
3837void
3838HumanSkeletonInterface::set_ori_right_hand(const float * new_ori_right_hand)
3839{
3840 set_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 */
3849void
3850HumanSkeletonInterface::set_ori_right_hand(unsigned int index, const float new_ori_right_hand)
3851{
3852 set_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 */
3859float
3860HumanSkeletonInterface::ori_right_hand_confidence() const
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 */
3869size_t
3870HumanSkeletonInterface::maxlenof_ori_right_hand_confidence() const
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 */
3880void
3881HumanSkeletonInterface::set_ori_right_hand_confidence(const float new_ori_right_hand_confidence)
3882{
3883 set_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 */
3891float *
3892HumanSkeletonInterface::ori_right_fingertip() const
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 */
3904float
3905HumanSkeletonInterface::ori_right_fingertip(unsigned int index) const
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 */
3917size_t
3918HumanSkeletonInterface::maxlenof_ori_right_fingertip() const
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 */
3928void
3929HumanSkeletonInterface::set_ori_right_fingertip(const float * new_ori_right_fingertip)
3930{
3931 set_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 */
3940void
3941HumanSkeletonInterface::set_ori_right_fingertip(unsigned int index, const float new_ori_right_fingertip)
3942{
3943 set_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 */
3950float
3951HumanSkeletonInterface::ori_right_fingertip_confidence() const
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 */
3960size_t
3961HumanSkeletonInterface::maxlenof_ori_right_fingertip_confidence() const
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 */
3971void
3972HumanSkeletonInterface::set_ori_right_fingertip_confidence(const float new_ori_right_fingertip_confidence)
3973{
3974 set_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 */
3982float *
3983HumanSkeletonInterface::ori_left_hip() const
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 */
3995float
3996HumanSkeletonInterface::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 */
4008size_t
4009HumanSkeletonInterface::maxlenof_ori_left_hip() const
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 */
4019void
4020HumanSkeletonInterface::set_ori_left_hip(const float * new_ori_left_hip)
4021{
4022 set_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 */
4031void
4032HumanSkeletonInterface::set_ori_left_hip(unsigned int index, const float new_ori_left_hip)
4033{
4034 set_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 */
4041float
4042HumanSkeletonInterface::ori_left_hip_confidence() const
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 */
4051size_t
4052HumanSkeletonInterface::maxlenof_ori_left_hip_confidence() const
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 */
4062void
4063HumanSkeletonInterface::set_ori_left_hip_confidence(const float new_ori_left_hip_confidence)
4064{
4065 set_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 */
4073float *
4074HumanSkeletonInterface::ori_left_knee() const
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 */
4086float
4087HumanSkeletonInterface::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 */
4099size_t
4100HumanSkeletonInterface::maxlenof_ori_left_knee() const
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 */
4110void
4111HumanSkeletonInterface::set_ori_left_knee(const float * new_ori_left_knee)
4112{
4113 set_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 */
4122void
4123HumanSkeletonInterface::set_ori_left_knee(unsigned int index, const float new_ori_left_knee)
4124{
4125 set_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 */
4132float
4133HumanSkeletonInterface::ori_left_knee_confidence() const
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 */
4142size_t
4143HumanSkeletonInterface::maxlenof_ori_left_knee_confidence() const
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 */
4153void
4154HumanSkeletonInterface::set_ori_left_knee_confidence(const float new_ori_left_knee_confidence)
4155{
4156 set_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 */
4164float *
4165HumanSkeletonInterface::ori_left_ankle() const
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 */
4177float
4178HumanSkeletonInterface::ori_left_ankle(unsigned int index) const
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 */
4190size_t
4191HumanSkeletonInterface::maxlenof_ori_left_ankle() const
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 */
4201void
4202HumanSkeletonInterface::set_ori_left_ankle(const float * new_ori_left_ankle)
4203{
4204 set_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 */
4213void
4214HumanSkeletonInterface::set_ori_left_ankle(unsigned int index, const float new_ori_left_ankle)
4215{
4216 set_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 */
4223float
4224HumanSkeletonInterface::ori_left_ankle_confidence() const
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 */
4233size_t
4234HumanSkeletonInterface::maxlenof_ori_left_ankle_confidence() const
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 */
4244void
4245HumanSkeletonInterface::set_ori_left_ankle_confidence(const float new_ori_left_ankle_confidence)
4246{
4247 set_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 */
4255float *
4256HumanSkeletonInterface::ori_left_foot() const
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 */
4268float
4269HumanSkeletonInterface::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 */
4281size_t
4282HumanSkeletonInterface::maxlenof_ori_left_foot() const
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 */
4292void
4293HumanSkeletonInterface::set_ori_left_foot(const float * new_ori_left_foot)
4294{
4295 set_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 */
4304void
4305HumanSkeletonInterface::set_ori_left_foot(unsigned int index, const float new_ori_left_foot)
4306{
4307 set_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 */
4314float
4315HumanSkeletonInterface::ori_left_foot_confidence() const
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 */
4324size_t
4325HumanSkeletonInterface::maxlenof_ori_left_foot_confidence() const
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 */
4335void
4336HumanSkeletonInterface::set_ori_left_foot_confidence(const float new_ori_left_foot_confidence)
4337{
4338 set_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 */
4346float *
4347HumanSkeletonInterface::ori_right_hip() const
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 */
4359float
4360HumanSkeletonInterface::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 */
4372size_t
4373HumanSkeletonInterface::maxlenof_ori_right_hip() const
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 */
4383void
4384HumanSkeletonInterface::set_ori_right_hip(const float * new_ori_right_hip)
4385{
4386 set_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 */
4395void
4396HumanSkeletonInterface::set_ori_right_hip(unsigned int index, const float new_ori_right_hip)
4397{
4398 set_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 */
4405float
4406HumanSkeletonInterface::ori_right_hip_confidence() const
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 */
4415size_t
4416HumanSkeletonInterface::maxlenof_ori_right_hip_confidence() const
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 */
4426void
4427HumanSkeletonInterface::set_ori_right_hip_confidence(const float new_ori_right_hip_confidence)
4428{
4429 set_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 */
4437float *
4438HumanSkeletonInterface::ori_right_knee() const
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 */
4450float
4451HumanSkeletonInterface::ori_right_knee(unsigned int index) const
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 */
4463size_t
4464HumanSkeletonInterface::maxlenof_ori_right_knee() const
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 */
4474void
4475HumanSkeletonInterface::set_ori_right_knee(const float * new_ori_right_knee)
4476{
4477 set_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 */
4486void
4487HumanSkeletonInterface::set_ori_right_knee(unsigned int index, const float new_ori_right_knee)
4488{
4489 set_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 */
4496float
4497HumanSkeletonInterface::ori_right_knee_confidence() const
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 */
4506size_t
4507HumanSkeletonInterface::maxlenof_ori_right_knee_confidence() const
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 */
4517void
4518HumanSkeletonInterface::set_ori_right_knee_confidence(const float new_ori_right_knee_confidence)
4519{
4520 set_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 */
4528float *
4529HumanSkeletonInterface::ori_right_ankle() const
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 */
4541float
4542HumanSkeletonInterface::ori_right_ankle(unsigned int index) const
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 */
4554size_t
4555HumanSkeletonInterface::maxlenof_ori_right_ankle() const
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 */
4565void
4566HumanSkeletonInterface::set_ori_right_ankle(const float * new_ori_right_ankle)
4567{
4568 set_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 */
4577void
4578HumanSkeletonInterface::set_ori_right_ankle(unsigned int index, const float new_ori_right_ankle)
4579{
4580 set_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 */
4587float
4588HumanSkeletonInterface::ori_right_ankle_confidence() const
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 */
4597size_t
4598HumanSkeletonInterface::maxlenof_ori_right_ankle_confidence() const
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 */
4608void
4609HumanSkeletonInterface::set_ori_right_ankle_confidence(const float new_ori_right_ankle_confidence)
4610{
4611 set_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 */
4619float *
4620HumanSkeletonInterface::ori_right_foot() const
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 */
4632float
4633HumanSkeletonInterface::ori_right_foot(unsigned int index) const
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 */
4645size_t
4646HumanSkeletonInterface::maxlenof_ori_right_foot() const
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 */
4656void
4657HumanSkeletonInterface::set_ori_right_foot(const float * new_ori_right_foot)
4658{
4659 set_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 */
4668void
4669HumanSkeletonInterface::set_ori_right_foot(unsigned int index, const float new_ori_right_foot)
4670{
4671 set_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 */
4678float
4679HumanSkeletonInterface::ori_right_foot_confidence() const
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 */
4688size_t
4689HumanSkeletonInterface::maxlenof_ori_right_foot_confidence() const
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 */
4699void
4700HumanSkeletonInterface::set_ori_right_foot_confidence(const float new_ori_right_foot_confidence)
4701{
4702 set_field(data->ori_right_foot_confidence, new_ori_right_foot_confidence);
4703}
4704
4705/* =========== message create =========== */
4706Message *
4707HumanSkeletonInterface::create_message(const char *type) const
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 */
4717void
4718HumanSkeletonInterface::copy_values(const Interface *other)
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
4728const char *
4729HumanSkeletonInterface::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 */
4742bool
4743HumanSkeletonInterface::message_valid(const Message *message) const
4744{
4745 return false;
4746}
4747
4748/// @cond INTERNALS
4749EXPORT_INTERFACE(HumanSkeletonInterface)
4750/// @endcond
4751
4752
4753} // end namespace fawkes
Base class for exceptions in Fawkes.
Definition: exception.h:36
HumanSkeletonInterface Fawkes BlackBoard Interface.
State
Current tracking state for the skeleton.
Base class for all Fawkes BlackBoard interfaces.
Definition: interface.h:80
const char * type() const
Get type of interface.
Definition: interface.cpp:652
Base class for all messages passed through interfaces in Fawkes BlackBoard.
Definition: message.h:44
Fawkes library namespace.