Fawkes API
Fawkes Development Version
|
00001 00002 /*************************************************************************** 00003 * HumanSkeletonInterface.cpp - Fawkes BlackBoard Interface - HumanSkeletonInterface 00004 * 00005 * Templated created: Thu Oct 12 10:49:19 2006 00006 * Copyright 2007-2011 Tim Niemueller 00007 * 00008 ****************************************************************************/ 00009 00010 /* This program is free software; you can redistribute it and/or modify 00011 * it under the terms of the GNU General Public License as published by 00012 * the Free Software Foundation; either version 2 of the License, or 00013 * (at your option) any later version. A runtime exception applies to 00014 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00015 * 00016 * This program is distributed in the hope that it will be useful, 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00019 * GNU Library General Public License for more details. 00020 * 00021 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00022 */ 00023 00024 #include <interfaces/HumanSkeletonInterface.h> 00025 00026 #include <core/exceptions/software.h> 00027 00028 #include <cstring> 00029 #include <cstdlib> 00030 00031 namespace fawkes { 00032 00033 /** @class HumanSkeletonInterface <interfaces/HumanSkeletonInterface.h> 00034 * HumanSkeletonInterface Fawkes BlackBoard Interface. 00035 * 00036 00037 * @ingroup FawkesInterfaces 00038 */ 00039 00040 00041 00042 /** Constructor */ 00043 HumanSkeletonInterface::HumanSkeletonInterface() : Interface() 00044 { 00045 data_size = sizeof(HumanSkeletonInterface_data_t); 00046 data_ptr = malloc(data_size); 00047 data = (HumanSkeletonInterface_data_t *)data_ptr; 00048 data_ts = (interface_data_ts_t *)data_ptr; 00049 memset(data_ptr, 0, data_size); 00050 add_fieldinfo(IFT_ENUM, "state", 1, &data->state, "State"); 00051 add_fieldinfo(IFT_UINT32, "user_id", 1, &data->user_id); 00052 add_fieldinfo(IFT_INT32, "visibility_history", 1, &data->visibility_history); 00053 add_fieldinfo(IFT_STRING, "pose", 32, data->pose); 00054 add_fieldinfo(IFT_FLOAT, "com", 3, &data->com); 00055 add_fieldinfo(IFT_FLOAT, "pos_head", 3, &data->pos_head); 00056 add_fieldinfo(IFT_FLOAT, "pos_head_confidence", 1, &data->pos_head_confidence); 00057 add_fieldinfo(IFT_FLOAT, "pos_neck", 3, &data->pos_neck); 00058 add_fieldinfo(IFT_FLOAT, "pos_neck_confidence", 1, &data->pos_neck_confidence); 00059 add_fieldinfo(IFT_FLOAT, "pos_torso", 3, &data->pos_torso); 00060 add_fieldinfo(IFT_FLOAT, "pos_torso_confidence", 1, &data->pos_torso_confidence); 00061 add_fieldinfo(IFT_FLOAT, "pos_waist", 3, &data->pos_waist); 00062 add_fieldinfo(IFT_FLOAT, "pos_waist_confidence", 1, &data->pos_waist_confidence); 00063 add_fieldinfo(IFT_FLOAT, "pos_left_collar", 3, &data->pos_left_collar); 00064 add_fieldinfo(IFT_FLOAT, "pos_left_collar_confidence", 1, &data->pos_left_collar_confidence); 00065 add_fieldinfo(IFT_FLOAT, "pos_left_shoulder", 3, &data->pos_left_shoulder); 00066 add_fieldinfo(IFT_FLOAT, "pos_left_shoulder_confidence", 1, &data->pos_left_shoulder_confidence); 00067 add_fieldinfo(IFT_FLOAT, "pos_left_elbow", 3, &data->pos_left_elbow); 00068 add_fieldinfo(IFT_FLOAT, "pos_left_elbow_confidence", 1, &data->pos_left_elbow_confidence); 00069 add_fieldinfo(IFT_FLOAT, "pos_left_wrist", 3, &data->pos_left_wrist); 00070 add_fieldinfo(IFT_FLOAT, "pos_left_wrist_confidence", 1, &data->pos_left_wrist_confidence); 00071 add_fieldinfo(IFT_FLOAT, "pos_left_hand", 3, &data->pos_left_hand); 00072 add_fieldinfo(IFT_FLOAT, "pos_left_hand_confidence", 1, &data->pos_left_hand_confidence); 00073 add_fieldinfo(IFT_FLOAT, "pos_left_fingertip", 3, &data->pos_left_fingertip); 00074 add_fieldinfo(IFT_FLOAT, "pos_left_fingertip_confidence", 1, &data->pos_left_fingertip_confidence); 00075 add_fieldinfo(IFT_FLOAT, "pos_right_collar", 3, &data->pos_right_collar); 00076 add_fieldinfo(IFT_FLOAT, "pos_right_collar_confidence", 1, &data->pos_right_collar_confidence); 00077 add_fieldinfo(IFT_FLOAT, "pos_right_shoulder", 3, &data->pos_right_shoulder); 00078 add_fieldinfo(IFT_FLOAT, "pos_right_shoulder_confidence", 1, &data->pos_right_shoulder_confidence); 00079 add_fieldinfo(IFT_FLOAT, "pos_right_elbow", 3, &data->pos_right_elbow); 00080 add_fieldinfo(IFT_FLOAT, "pos_right_elbow_confidence", 1, &data->pos_right_elbow_confidence); 00081 add_fieldinfo(IFT_FLOAT, "pos_right_wrist", 3, &data->pos_right_wrist); 00082 add_fieldinfo(IFT_FLOAT, "pos_right_wrist_confidence", 1, &data->pos_right_wrist_confidence); 00083 add_fieldinfo(IFT_FLOAT, "pos_right_hand", 3, &data->pos_right_hand); 00084 add_fieldinfo(IFT_FLOAT, "pos_right_hand_confidence", 1, &data->pos_right_hand_confidence); 00085 add_fieldinfo(IFT_FLOAT, "pos_right_fingertip", 3, &data->pos_right_fingertip); 00086 add_fieldinfo(IFT_FLOAT, "pos_right_fingertip_confidence", 1, &data->pos_right_fingertip_confidence); 00087 add_fieldinfo(IFT_FLOAT, "pos_left_hip", 3, &data->pos_left_hip); 00088 add_fieldinfo(IFT_FLOAT, "pos_left_hip_confidence", 1, &data->pos_left_hip_confidence); 00089 add_fieldinfo(IFT_FLOAT, "pos_left_knee", 3, &data->pos_left_knee); 00090 add_fieldinfo(IFT_FLOAT, "pos_left_knee_confidence", 1, &data->pos_left_knee_confidence); 00091 add_fieldinfo(IFT_FLOAT, "pos_left_ankle", 3, &data->pos_left_ankle); 00092 add_fieldinfo(IFT_FLOAT, "pos_left_ankle_confidence", 1, &data->pos_left_ankle_confidence); 00093 add_fieldinfo(IFT_FLOAT, "pos_left_foot", 3, &data->pos_left_foot); 00094 add_fieldinfo(IFT_FLOAT, "pos_left_foot_confidence", 1, &data->pos_left_foot_confidence); 00095 add_fieldinfo(IFT_FLOAT, "pos_right_hip", 3, &data->pos_right_hip); 00096 add_fieldinfo(IFT_FLOAT, "pos_right_hip_confidence", 1, &data->pos_right_hip_confidence); 00097 add_fieldinfo(IFT_FLOAT, "pos_right_knee", 3, &data->pos_right_knee); 00098 add_fieldinfo(IFT_FLOAT, "pos_right_knee_confidence", 1, &data->pos_right_knee_confidence); 00099 add_fieldinfo(IFT_FLOAT, "pos_right_ankle", 3, &data->pos_right_ankle); 00100 add_fieldinfo(IFT_FLOAT, "pos_right_ankle_confidence", 1, &data->pos_right_ankle_confidence); 00101 add_fieldinfo(IFT_FLOAT, "pos_right_foot", 3, &data->pos_right_foot); 00102 add_fieldinfo(IFT_FLOAT, "pos_right_foot_confidence", 1, &data->pos_right_foot_confidence); 00103 add_fieldinfo(IFT_FLOAT, "ori_head", 9, &data->ori_head); 00104 add_fieldinfo(IFT_FLOAT, "ori_head_confidence", 1, &data->ori_head_confidence); 00105 add_fieldinfo(IFT_FLOAT, "ori_neck", 9, &data->ori_neck); 00106 add_fieldinfo(IFT_FLOAT, "ori_neck_confidence", 1, &data->ori_neck_confidence); 00107 add_fieldinfo(IFT_FLOAT, "ori_torso", 9, &data->ori_torso); 00108 add_fieldinfo(IFT_FLOAT, "ori_torso_confidence", 1, &data->ori_torso_confidence); 00109 add_fieldinfo(IFT_FLOAT, "ori_waist", 9, &data->ori_waist); 00110 add_fieldinfo(IFT_FLOAT, "ori_waist_confidence", 1, &data->ori_waist_confidence); 00111 add_fieldinfo(IFT_FLOAT, "ori_left_collar", 9, &data->ori_left_collar); 00112 add_fieldinfo(IFT_FLOAT, "ori_left_collar_confidence", 1, &data->ori_left_collar_confidence); 00113 add_fieldinfo(IFT_FLOAT, "ori_left_shoulder", 9, &data->ori_left_shoulder); 00114 add_fieldinfo(IFT_FLOAT, "ori_left_shoulder_confidence", 1, &data->ori_left_shoulder_confidence); 00115 add_fieldinfo(IFT_FLOAT, "ori_left_elbow", 9, &data->ori_left_elbow); 00116 add_fieldinfo(IFT_FLOAT, "ori_left_elbow_confidence", 1, &data->ori_left_elbow_confidence); 00117 add_fieldinfo(IFT_FLOAT, "ori_left_wrist", 9, &data->ori_left_wrist); 00118 add_fieldinfo(IFT_FLOAT, "ori_left_wrist_confidence", 1, &data->ori_left_wrist_confidence); 00119 add_fieldinfo(IFT_FLOAT, "ori_left_hand", 9, &data->ori_left_hand); 00120 add_fieldinfo(IFT_FLOAT, "ori_left_hand_confidence", 1, &data->ori_left_hand_confidence); 00121 add_fieldinfo(IFT_FLOAT, "ori_left_fingertip", 9, &data->ori_left_fingertip); 00122 add_fieldinfo(IFT_FLOAT, "ori_left_fingertip_confidence", 1, &data->ori_left_fingertip_confidence); 00123 add_fieldinfo(IFT_FLOAT, "ori_right_collar", 9, &data->ori_right_collar); 00124 add_fieldinfo(IFT_FLOAT, "ori_right_collar_confidence", 1, &data->ori_right_collar_confidence); 00125 add_fieldinfo(IFT_FLOAT, "ori_right_shoulder", 9, &data->ori_right_shoulder); 00126 add_fieldinfo(IFT_FLOAT, "ori_right_shoulder_confidence", 1, &data->ori_right_shoulder_confidence); 00127 add_fieldinfo(IFT_FLOAT, "ori_right_elbow", 9, &data->ori_right_elbow); 00128 add_fieldinfo(IFT_FLOAT, "ori_right_elbow_confidence", 1, &data->ori_right_elbow_confidence); 00129 add_fieldinfo(IFT_FLOAT, "ori_right_wrist", 9, &data->ori_right_wrist); 00130 add_fieldinfo(IFT_FLOAT, "ori_right_wrist_confidence", 1, &data->ori_right_wrist_confidence); 00131 add_fieldinfo(IFT_FLOAT, "ori_right_hand", 9, &data->ori_right_hand); 00132 add_fieldinfo(IFT_FLOAT, "ori_right_hand_confidence", 1, &data->ori_right_hand_confidence); 00133 add_fieldinfo(IFT_FLOAT, "ori_right_fingertip", 9, &data->ori_right_fingertip); 00134 add_fieldinfo(IFT_FLOAT, "ori_right_fingertip_confidence", 1, &data->ori_right_fingertip_confidence); 00135 add_fieldinfo(IFT_FLOAT, "ori_left_hip", 9, &data->ori_left_hip); 00136 add_fieldinfo(IFT_FLOAT, "ori_left_hip_confidence", 1, &data->ori_left_hip_confidence); 00137 add_fieldinfo(IFT_FLOAT, "ori_left_knee", 9, &data->ori_left_knee); 00138 add_fieldinfo(IFT_FLOAT, "ori_left_knee_confidence", 1, &data->ori_left_knee_confidence); 00139 add_fieldinfo(IFT_FLOAT, "ori_left_ankle", 9, &data->ori_left_ankle); 00140 add_fieldinfo(IFT_FLOAT, "ori_left_ankle_confidence", 1, &data->ori_left_ankle_confidence); 00141 add_fieldinfo(IFT_FLOAT, "ori_left_foot", 9, &data->ori_left_foot); 00142 add_fieldinfo(IFT_FLOAT, "ori_left_foot_confidence", 1, &data->ori_left_foot_confidence); 00143 add_fieldinfo(IFT_FLOAT, "ori_right_hip", 9, &data->ori_right_hip); 00144 add_fieldinfo(IFT_FLOAT, "ori_right_hip_confidence", 1, &data->ori_right_hip_confidence); 00145 add_fieldinfo(IFT_FLOAT, "ori_right_knee", 9, &data->ori_right_knee); 00146 add_fieldinfo(IFT_FLOAT, "ori_right_knee_confidence", 1, &data->ori_right_knee_confidence); 00147 add_fieldinfo(IFT_FLOAT, "ori_right_ankle", 9, &data->ori_right_ankle); 00148 add_fieldinfo(IFT_FLOAT, "ori_right_ankle_confidence", 1, &data->ori_right_ankle_confidence); 00149 add_fieldinfo(IFT_FLOAT, "ori_right_foot", 9, &data->ori_right_foot); 00150 add_fieldinfo(IFT_FLOAT, "ori_right_foot_confidence", 1, &data->ori_right_foot_confidence); 00151 unsigned char tmp_hash[] = {0x5f, 0x47, 0x2f, 0xb3, 0x8b, 0xf1, 0xe1, 0xa, 0xb9, 0x42, 0x34, 0xea, 0x83, 0x43, 0x94, 0x37}; 00152 set_hash(tmp_hash); 00153 } 00154 00155 /** Destructor */ 00156 HumanSkeletonInterface::~HumanSkeletonInterface() 00157 { 00158 free(data_ptr); 00159 } 00160 /** Convert State constant to string. 00161 * @param value value to convert to string 00162 * @return constant value as string. 00163 */ 00164 const char * 00165 HumanSkeletonInterface::tostring_State(State value) const 00166 { 00167 switch (value) { 00168 case STATE_INVALID: return "STATE_INVALID"; 00169 case STATE_DETECTING_POSE: return "STATE_DETECTING_POSE"; 00170 case STATE_CALIBRATING: return "STATE_CALIBRATING"; 00171 case STATE_TRACKING: return "STATE_TRACKING"; 00172 default: return "UNKNOWN"; 00173 } 00174 } 00175 /* Methods */ 00176 /** Get state value. 00177 * Current state. 00178 * @return state value 00179 */ 00180 HumanSkeletonInterface::State 00181 HumanSkeletonInterface::state() const 00182 { 00183 return (HumanSkeletonInterface::State)data->state; 00184 } 00185 00186 /** Get maximum length of state value. 00187 * @return length of state value, can be length of the array or number of 00188 * maximum number of characters for a string 00189 */ 00190 size_t 00191 HumanSkeletonInterface::maxlenof_state() const 00192 { 00193 return 1; 00194 } 00195 00196 /** Set state value. 00197 * Current state. 00198 * @param new_state new state value 00199 */ 00200 void 00201 HumanSkeletonInterface::set_state(const State new_state) 00202 { 00203 data->state = new_state; 00204 data_changed = true; 00205 } 00206 00207 /** Get user_id value. 00208 * Tracking ID of this user. 00209 * @return user_id value 00210 */ 00211 uint32_t 00212 HumanSkeletonInterface::user_id() const 00213 { 00214 return data->user_id; 00215 } 00216 00217 /** Get maximum length of user_id value. 00218 * @return length of user_id value, can be length of the array or number of 00219 * maximum number of characters for a string 00220 */ 00221 size_t 00222 HumanSkeletonInterface::maxlenof_user_id() const 00223 { 00224 return 1; 00225 } 00226 00227 /** Set user_id value. 00228 * Tracking ID of this user. 00229 * @param new_user_id new user_id value 00230 */ 00231 void 00232 HumanSkeletonInterface::set_user_id(const uint32_t new_user_id) 00233 { 00234 data->user_id = new_user_id; 00235 data_changed = true; 00236 } 00237 00238 /** Get visibility_history value. 00239 * 00240 The visibility history indicates the persistence of user sightings. 00241 A positive value indicates the number of successful consecutive sightings 00242 of the user (center of mass not equal to zero), the absolute of a negative 00243 value gives the number of consecutive negative (non-) sightings. The value 00244 is zero only if uninitialized. 00245 00246 * @return visibility_history value 00247 */ 00248 int32_t 00249 HumanSkeletonInterface::visibility_history() const 00250 { 00251 return data->visibility_history; 00252 } 00253 00254 /** Get maximum length of visibility_history value. 00255 * @return length of visibility_history value, can be length of the array or number of 00256 * maximum number of characters for a string 00257 */ 00258 size_t 00259 HumanSkeletonInterface::maxlenof_visibility_history() const 00260 { 00261 return 1; 00262 } 00263 00264 /** Set visibility_history value. 00265 * 00266 The visibility history indicates the persistence of user sightings. 00267 A positive value indicates the number of successful consecutive sightings 00268 of the user (center of mass not equal to zero), the absolute of a negative 00269 value gives the number of consecutive negative (non-) sightings. The value 00270 is zero only if uninitialized. 00271 00272 * @param new_visibility_history new visibility_history value 00273 */ 00274 void 00275 HumanSkeletonInterface::set_visibility_history(const int32_t new_visibility_history) 00276 { 00277 data->visibility_history = new_visibility_history; 00278 data_changed = true; 00279 } 00280 00281 /** Get pose value. 00282 * Detected user pose. 00283 * @return pose value 00284 */ 00285 char * 00286 HumanSkeletonInterface::pose() const 00287 { 00288 return data->pose; 00289 } 00290 00291 /** Get maximum length of pose value. 00292 * @return length of pose value, can be length of the array or number of 00293 * maximum number of characters for a string 00294 */ 00295 size_t 00296 HumanSkeletonInterface::maxlenof_pose() const 00297 { 00298 return 32; 00299 } 00300 00301 /** Set pose value. 00302 * Detected user pose. 00303 * @param new_pose new pose value 00304 */ 00305 void 00306 HumanSkeletonInterface::set_pose(const char * new_pose) 00307 { 00308 strncpy(data->pose, new_pose, sizeof(data->pose)); 00309 data_changed = true; 00310 } 00311 00312 /** Get com value. 00313 * Center of mass. 00314 * @return com value 00315 */ 00316 float * 00317 HumanSkeletonInterface::com() const 00318 { 00319 return data->com; 00320 } 00321 00322 /** Get com value at given index. 00323 * Center of mass. 00324 * @param index index of value 00325 * @return com value 00326 * @exception Exception thrown if index is out of bounds 00327 */ 00328 float 00329 HumanSkeletonInterface::com(unsigned int index) const 00330 { 00331 if (index > 3) { 00332 throw Exception("Index value %u out of bounds (0..3)", index); 00333 } 00334 return data->com[index]; 00335 } 00336 00337 /** Get maximum length of com value. 00338 * @return length of com value, can be length of the array or number of 00339 * maximum number of characters for a string 00340 */ 00341 size_t 00342 HumanSkeletonInterface::maxlenof_com() const 00343 { 00344 return 3; 00345 } 00346 00347 /** Set com value. 00348 * Center of mass. 00349 * @param new_com new com value 00350 */ 00351 void 00352 HumanSkeletonInterface::set_com(const float * new_com) 00353 { 00354 memcpy(data->com, new_com, sizeof(float) * 3); 00355 data_changed = true; 00356 } 00357 00358 /** Set com value at given index. 00359 * Center of mass. 00360 * @param new_com new com value 00361 * @param index index for of the value 00362 */ 00363 void 00364 HumanSkeletonInterface::set_com(unsigned int index, const float new_com) 00365 { 00366 if (index > 3) { 00367 throw Exception("Index value %u out of bounds (0..3)", index); 00368 } 00369 data->com[index] = new_com; 00370 data_changed = true; 00371 } 00372 /** Get pos_head value. 00373 * Head position vector. 00374 * @return pos_head value 00375 */ 00376 float * 00377 HumanSkeletonInterface::pos_head() const 00378 { 00379 return data->pos_head; 00380 } 00381 00382 /** Get pos_head value at given index. 00383 * Head position vector. 00384 * @param index index of value 00385 * @return pos_head value 00386 * @exception Exception thrown if index is out of bounds 00387 */ 00388 float 00389 HumanSkeletonInterface::pos_head(unsigned int index) const 00390 { 00391 if (index > 3) { 00392 throw Exception("Index value %u out of bounds (0..3)", index); 00393 } 00394 return data->pos_head[index]; 00395 } 00396 00397 /** Get maximum length of pos_head value. 00398 * @return length of pos_head value, can be length of the array or number of 00399 * maximum number of characters for a string 00400 */ 00401 size_t 00402 HumanSkeletonInterface::maxlenof_pos_head() const 00403 { 00404 return 3; 00405 } 00406 00407 /** Set pos_head value. 00408 * Head position vector. 00409 * @param new_pos_head new pos_head value 00410 */ 00411 void 00412 HumanSkeletonInterface::set_pos_head(const float * new_pos_head) 00413 { 00414 memcpy(data->pos_head, new_pos_head, sizeof(float) * 3); 00415 data_changed = true; 00416 } 00417 00418 /** Set pos_head value at given index. 00419 * Head position vector. 00420 * @param new_pos_head new pos_head value 00421 * @param index index for of the value 00422 */ 00423 void 00424 HumanSkeletonInterface::set_pos_head(unsigned int index, const float new_pos_head) 00425 { 00426 if (index > 3) { 00427 throw Exception("Index value %u out of bounds (0..3)", index); 00428 } 00429 data->pos_head[index] = new_pos_head; 00430 data_changed = true; 00431 } 00432 /** Get pos_head_confidence value. 00433 * 00434 Head position confidence. 00435 * @return pos_head_confidence value 00436 */ 00437 float 00438 HumanSkeletonInterface::pos_head_confidence() const 00439 { 00440 return data->pos_head_confidence; 00441 } 00442 00443 /** Get maximum length of pos_head_confidence value. 00444 * @return length of pos_head_confidence value, can be length of the array or number of 00445 * maximum number of characters for a string 00446 */ 00447 size_t 00448 HumanSkeletonInterface::maxlenof_pos_head_confidence() const 00449 { 00450 return 1; 00451 } 00452 00453 /** Set pos_head_confidence value. 00454 * 00455 Head position confidence. 00456 * @param new_pos_head_confidence new pos_head_confidence value 00457 */ 00458 void 00459 HumanSkeletonInterface::set_pos_head_confidence(const float new_pos_head_confidence) 00460 { 00461 data->pos_head_confidence = new_pos_head_confidence; 00462 data_changed = true; 00463 } 00464 00465 /** Get pos_neck value. 00466 * Neck position vector. 00467 * @return pos_neck value 00468 */ 00469 float * 00470 HumanSkeletonInterface::pos_neck() const 00471 { 00472 return data->pos_neck; 00473 } 00474 00475 /** Get pos_neck value at given index. 00476 * Neck position vector. 00477 * @param index index of value 00478 * @return pos_neck value 00479 * @exception Exception thrown if index is out of bounds 00480 */ 00481 float 00482 HumanSkeletonInterface::pos_neck(unsigned int index) const 00483 { 00484 if (index > 3) { 00485 throw Exception("Index value %u out of bounds (0..3)", index); 00486 } 00487 return data->pos_neck[index]; 00488 } 00489 00490 /** Get maximum length of pos_neck value. 00491 * @return length of pos_neck value, can be length of the array or number of 00492 * maximum number of characters for a string 00493 */ 00494 size_t 00495 HumanSkeletonInterface::maxlenof_pos_neck() const 00496 { 00497 return 3; 00498 } 00499 00500 /** Set pos_neck value. 00501 * Neck position vector. 00502 * @param new_pos_neck new pos_neck value 00503 */ 00504 void 00505 HumanSkeletonInterface::set_pos_neck(const float * new_pos_neck) 00506 { 00507 memcpy(data->pos_neck, new_pos_neck, sizeof(float) * 3); 00508 data_changed = true; 00509 } 00510 00511 /** Set pos_neck value at given index. 00512 * Neck position vector. 00513 * @param new_pos_neck new pos_neck value 00514 * @param index index for of the value 00515 */ 00516 void 00517 HumanSkeletonInterface::set_pos_neck(unsigned int index, const float new_pos_neck) 00518 { 00519 if (index > 3) { 00520 throw Exception("Index value %u out of bounds (0..3)", index); 00521 } 00522 data->pos_neck[index] = new_pos_neck; 00523 data_changed = true; 00524 } 00525 /** Get pos_neck_confidence value. 00526 * 00527 Neck position confidence. 00528 * @return pos_neck_confidence value 00529 */ 00530 float 00531 HumanSkeletonInterface::pos_neck_confidence() const 00532 { 00533 return data->pos_neck_confidence; 00534 } 00535 00536 /** Get maximum length of pos_neck_confidence value. 00537 * @return length of pos_neck_confidence value, can be length of the array or number of 00538 * maximum number of characters for a string 00539 */ 00540 size_t 00541 HumanSkeletonInterface::maxlenof_pos_neck_confidence() const 00542 { 00543 return 1; 00544 } 00545 00546 /** Set pos_neck_confidence value. 00547 * 00548 Neck position confidence. 00549 * @param new_pos_neck_confidence new pos_neck_confidence value 00550 */ 00551 void 00552 HumanSkeletonInterface::set_pos_neck_confidence(const float new_pos_neck_confidence) 00553 { 00554 data->pos_neck_confidence = new_pos_neck_confidence; 00555 data_changed = true; 00556 } 00557 00558 /** Get pos_torso value. 00559 * Torso position vector. 00560 * @return pos_torso value 00561 */ 00562 float * 00563 HumanSkeletonInterface::pos_torso() const 00564 { 00565 return data->pos_torso; 00566 } 00567 00568 /** Get pos_torso value at given index. 00569 * Torso position vector. 00570 * @param index index of value 00571 * @return pos_torso value 00572 * @exception Exception thrown if index is out of bounds 00573 */ 00574 float 00575 HumanSkeletonInterface::pos_torso(unsigned int index) const 00576 { 00577 if (index > 3) { 00578 throw Exception("Index value %u out of bounds (0..3)", index); 00579 } 00580 return data->pos_torso[index]; 00581 } 00582 00583 /** Get maximum length of pos_torso value. 00584 * @return length of pos_torso value, can be length of the array or number of 00585 * maximum number of characters for a string 00586 */ 00587 size_t 00588 HumanSkeletonInterface::maxlenof_pos_torso() const 00589 { 00590 return 3; 00591 } 00592 00593 /** Set pos_torso value. 00594 * Torso position vector. 00595 * @param new_pos_torso new pos_torso value 00596 */ 00597 void 00598 HumanSkeletonInterface::set_pos_torso(const float * new_pos_torso) 00599 { 00600 memcpy(data->pos_torso, new_pos_torso, sizeof(float) * 3); 00601 data_changed = true; 00602 } 00603 00604 /** Set pos_torso value at given index. 00605 * Torso position vector. 00606 * @param new_pos_torso new pos_torso value 00607 * @param index index for of the value 00608 */ 00609 void 00610 HumanSkeletonInterface::set_pos_torso(unsigned int index, const float new_pos_torso) 00611 { 00612 if (index > 3) { 00613 throw Exception("Index value %u out of bounds (0..3)", index); 00614 } 00615 data->pos_torso[index] = new_pos_torso; 00616 data_changed = true; 00617 } 00618 /** Get pos_torso_confidence value. 00619 * 00620 Torso position confidence. 00621 * @return pos_torso_confidence value 00622 */ 00623 float 00624 HumanSkeletonInterface::pos_torso_confidence() const 00625 { 00626 return data->pos_torso_confidence; 00627 } 00628 00629 /** Get maximum length of pos_torso_confidence value. 00630 * @return length of pos_torso_confidence value, can be length of the array or number of 00631 * maximum number of characters for a string 00632 */ 00633 size_t 00634 HumanSkeletonInterface::maxlenof_pos_torso_confidence() const 00635 { 00636 return 1; 00637 } 00638 00639 /** Set pos_torso_confidence value. 00640 * 00641 Torso position confidence. 00642 * @param new_pos_torso_confidence new pos_torso_confidence value 00643 */ 00644 void 00645 HumanSkeletonInterface::set_pos_torso_confidence(const float new_pos_torso_confidence) 00646 { 00647 data->pos_torso_confidence = new_pos_torso_confidence; 00648 data_changed = true; 00649 } 00650 00651 /** Get pos_waist value. 00652 * Waist position vector. 00653 * @return pos_waist value 00654 */ 00655 float * 00656 HumanSkeletonInterface::pos_waist() const 00657 { 00658 return data->pos_waist; 00659 } 00660 00661 /** Get pos_waist value at given index. 00662 * Waist position vector. 00663 * @param index index of value 00664 * @return pos_waist value 00665 * @exception Exception thrown if index is out of bounds 00666 */ 00667 float 00668 HumanSkeletonInterface::pos_waist(unsigned int index) const 00669 { 00670 if (index > 3) { 00671 throw Exception("Index value %u out of bounds (0..3)", index); 00672 } 00673 return data->pos_waist[index]; 00674 } 00675 00676 /** Get maximum length of pos_waist value. 00677 * @return length of pos_waist value, can be length of the array or number of 00678 * maximum number of characters for a string 00679 */ 00680 size_t 00681 HumanSkeletonInterface::maxlenof_pos_waist() const 00682 { 00683 return 3; 00684 } 00685 00686 /** Set pos_waist value. 00687 * Waist position vector. 00688 * @param new_pos_waist new pos_waist value 00689 */ 00690 void 00691 HumanSkeletonInterface::set_pos_waist(const float * new_pos_waist) 00692 { 00693 memcpy(data->pos_waist, new_pos_waist, sizeof(float) * 3); 00694 data_changed = true; 00695 } 00696 00697 /** Set pos_waist value at given index. 00698 * Waist position vector. 00699 * @param new_pos_waist new pos_waist value 00700 * @param index index for of the value 00701 */ 00702 void 00703 HumanSkeletonInterface::set_pos_waist(unsigned int index, const float new_pos_waist) 00704 { 00705 if (index > 3) { 00706 throw Exception("Index value %u out of bounds (0..3)", index); 00707 } 00708 data->pos_waist[index] = new_pos_waist; 00709 data_changed = true; 00710 } 00711 /** Get pos_waist_confidence value. 00712 * 00713 Waist position confidence. 00714 * @return pos_waist_confidence value 00715 */ 00716 float 00717 HumanSkeletonInterface::pos_waist_confidence() const 00718 { 00719 return data->pos_waist_confidence; 00720 } 00721 00722 /** Get maximum length of pos_waist_confidence value. 00723 * @return length of pos_waist_confidence value, can be length of the array or number of 00724 * maximum number of characters for a string 00725 */ 00726 size_t 00727 HumanSkeletonInterface::maxlenof_pos_waist_confidence() const 00728 { 00729 return 1; 00730 } 00731 00732 /** Set pos_waist_confidence value. 00733 * 00734 Waist position confidence. 00735 * @param new_pos_waist_confidence new pos_waist_confidence value 00736 */ 00737 void 00738 HumanSkeletonInterface::set_pos_waist_confidence(const float new_pos_waist_confidence) 00739 { 00740 data->pos_waist_confidence = new_pos_waist_confidence; 00741 data_changed = true; 00742 } 00743 00744 /** Get pos_left_collar value. 00745 * 00746 Left position vector. 00747 * @return pos_left_collar value 00748 */ 00749 float * 00750 HumanSkeletonInterface::pos_left_collar() const 00751 { 00752 return data->pos_left_collar; 00753 } 00754 00755 /** Get pos_left_collar value at given index. 00756 * 00757 Left position vector. 00758 * @param index index of value 00759 * @return pos_left_collar value 00760 * @exception Exception thrown if index is out of bounds 00761 */ 00762 float 00763 HumanSkeletonInterface::pos_left_collar(unsigned int index) const 00764 { 00765 if (index > 3) { 00766 throw Exception("Index value %u out of bounds (0..3)", index); 00767 } 00768 return data->pos_left_collar[index]; 00769 } 00770 00771 /** Get maximum length of pos_left_collar value. 00772 * @return length of pos_left_collar value, can be length of the array or number of 00773 * maximum number of characters for a string 00774 */ 00775 size_t 00776 HumanSkeletonInterface::maxlenof_pos_left_collar() const 00777 { 00778 return 3; 00779 } 00780 00781 /** Set pos_left_collar value. 00782 * 00783 Left position vector. 00784 * @param new_pos_left_collar new pos_left_collar value 00785 */ 00786 void 00787 HumanSkeletonInterface::set_pos_left_collar(const float * new_pos_left_collar) 00788 { 00789 memcpy(data->pos_left_collar, new_pos_left_collar, sizeof(float) * 3); 00790 data_changed = true; 00791 } 00792 00793 /** Set pos_left_collar value at given index. 00794 * 00795 Left position vector. 00796 * @param new_pos_left_collar new pos_left_collar value 00797 * @param index index for of the value 00798 */ 00799 void 00800 HumanSkeletonInterface::set_pos_left_collar(unsigned int index, const float new_pos_left_collar) 00801 { 00802 if (index > 3) { 00803 throw Exception("Index value %u out of bounds (0..3)", index); 00804 } 00805 data->pos_left_collar[index] = new_pos_left_collar; 00806 data_changed = true; 00807 } 00808 /** Get pos_left_collar_confidence value. 00809 * 00810 Left position confidence. 00811 * @return pos_left_collar_confidence value 00812 */ 00813 float 00814 HumanSkeletonInterface::pos_left_collar_confidence() const 00815 { 00816 return data->pos_left_collar_confidence; 00817 } 00818 00819 /** Get maximum length of pos_left_collar_confidence value. 00820 * @return length of pos_left_collar_confidence value, can be length of the array or number of 00821 * maximum number of characters for a string 00822 */ 00823 size_t 00824 HumanSkeletonInterface::maxlenof_pos_left_collar_confidence() const 00825 { 00826 return 1; 00827 } 00828 00829 /** Set pos_left_collar_confidence value. 00830 * 00831 Left position confidence. 00832 * @param new_pos_left_collar_confidence new pos_left_collar_confidence value 00833 */ 00834 void 00835 HumanSkeletonInterface::set_pos_left_collar_confidence(const float new_pos_left_collar_confidence) 00836 { 00837 data->pos_left_collar_confidence = new_pos_left_collar_confidence; 00838 data_changed = true; 00839 } 00840 00841 /** Get pos_left_shoulder value. 00842 * 00843 Left shoulder position vector. 00844 * @return pos_left_shoulder value 00845 */ 00846 float * 00847 HumanSkeletonInterface::pos_left_shoulder() const 00848 { 00849 return data->pos_left_shoulder; 00850 } 00851 00852 /** Get pos_left_shoulder value at given index. 00853 * 00854 Left shoulder position vector. 00855 * @param index index of value 00856 * @return pos_left_shoulder value 00857 * @exception Exception thrown if index is out of bounds 00858 */ 00859 float 00860 HumanSkeletonInterface::pos_left_shoulder(unsigned int index) const 00861 { 00862 if (index > 3) { 00863 throw Exception("Index value %u out of bounds (0..3)", index); 00864 } 00865 return data->pos_left_shoulder[index]; 00866 } 00867 00868 /** Get maximum length of pos_left_shoulder value. 00869 * @return length of pos_left_shoulder value, can be length of the array or number of 00870 * maximum number of characters for a string 00871 */ 00872 size_t 00873 HumanSkeletonInterface::maxlenof_pos_left_shoulder() const 00874 { 00875 return 3; 00876 } 00877 00878 /** Set pos_left_shoulder value. 00879 * 00880 Left shoulder position vector. 00881 * @param new_pos_left_shoulder new pos_left_shoulder value 00882 */ 00883 void 00884 HumanSkeletonInterface::set_pos_left_shoulder(const float * new_pos_left_shoulder) 00885 { 00886 memcpy(data->pos_left_shoulder, new_pos_left_shoulder, sizeof(float) * 3); 00887 data_changed = true; 00888 } 00889 00890 /** Set pos_left_shoulder value at given index. 00891 * 00892 Left shoulder position vector. 00893 * @param new_pos_left_shoulder new pos_left_shoulder value 00894 * @param index index for of the value 00895 */ 00896 void 00897 HumanSkeletonInterface::set_pos_left_shoulder(unsigned int index, const float new_pos_left_shoulder) 00898 { 00899 if (index > 3) { 00900 throw Exception("Index value %u out of bounds (0..3)", index); 00901 } 00902 data->pos_left_shoulder[index] = new_pos_left_shoulder; 00903 data_changed = true; 00904 } 00905 /** Get pos_left_shoulder_confidence value. 00906 * 00907 Left shoulder position confidence. 00908 * @return pos_left_shoulder_confidence value 00909 */ 00910 float 00911 HumanSkeletonInterface::pos_left_shoulder_confidence() const 00912 { 00913 return data->pos_left_shoulder_confidence; 00914 } 00915 00916 /** Get maximum length of pos_left_shoulder_confidence value. 00917 * @return length of pos_left_shoulder_confidence value, can be length of the array or number of 00918 * maximum number of characters for a string 00919 */ 00920 size_t 00921 HumanSkeletonInterface::maxlenof_pos_left_shoulder_confidence() const 00922 { 00923 return 1; 00924 } 00925 00926 /** Set pos_left_shoulder_confidence value. 00927 * 00928 Left shoulder position confidence. 00929 * @param new_pos_left_shoulder_confidence new pos_left_shoulder_confidence value 00930 */ 00931 void 00932 HumanSkeletonInterface::set_pos_left_shoulder_confidence(const float new_pos_left_shoulder_confidence) 00933 { 00934 data->pos_left_shoulder_confidence = new_pos_left_shoulder_confidence; 00935 data_changed = true; 00936 } 00937 00938 /** Get pos_left_elbow value. 00939 * 00940 Left elbow position vector. 00941 * @return pos_left_elbow value 00942 */ 00943 float * 00944 HumanSkeletonInterface::pos_left_elbow() const 00945 { 00946 return data->pos_left_elbow; 00947 } 00948 00949 /** Get pos_left_elbow value at given index. 00950 * 00951 Left elbow position vector. 00952 * @param index index of value 00953 * @return pos_left_elbow value 00954 * @exception Exception thrown if index is out of bounds 00955 */ 00956 float 00957 HumanSkeletonInterface::pos_left_elbow(unsigned int index) const 00958 { 00959 if (index > 3) { 00960 throw Exception("Index value %u out of bounds (0..3)", index); 00961 } 00962 return data->pos_left_elbow[index]; 00963 } 00964 00965 /** Get maximum length of pos_left_elbow value. 00966 * @return length of pos_left_elbow value, can be length of the array or number of 00967 * maximum number of characters for a string 00968 */ 00969 size_t 00970 HumanSkeletonInterface::maxlenof_pos_left_elbow() const 00971 { 00972 return 3; 00973 } 00974 00975 /** Set pos_left_elbow value. 00976 * 00977 Left elbow position vector. 00978 * @param new_pos_left_elbow new pos_left_elbow value 00979 */ 00980 void 00981 HumanSkeletonInterface::set_pos_left_elbow(const float * new_pos_left_elbow) 00982 { 00983 memcpy(data->pos_left_elbow, new_pos_left_elbow, sizeof(float) * 3); 00984 data_changed = true; 00985 } 00986 00987 /** Set pos_left_elbow value at given index. 00988 * 00989 Left elbow position vector. 00990 * @param new_pos_left_elbow new pos_left_elbow value 00991 * @param index index for of the value 00992 */ 00993 void 00994 HumanSkeletonInterface::set_pos_left_elbow(unsigned int index, const float new_pos_left_elbow) 00995 { 00996 if (index > 3) { 00997 throw Exception("Index value %u out of bounds (0..3)", index); 00998 } 00999 data->pos_left_elbow[index] = new_pos_left_elbow; 01000 data_changed = true; 01001 } 01002 /** Get pos_left_elbow_confidence value. 01003 * 01004 Left elbow position confidence. 01005 * @return pos_left_elbow_confidence value 01006 */ 01007 float 01008 HumanSkeletonInterface::pos_left_elbow_confidence() const 01009 { 01010 return data->pos_left_elbow_confidence; 01011 } 01012 01013 /** Get maximum length of pos_left_elbow_confidence value. 01014 * @return length of pos_left_elbow_confidence value, can be length of the array or number of 01015 * maximum number of characters for a string 01016 */ 01017 size_t 01018 HumanSkeletonInterface::maxlenof_pos_left_elbow_confidence() const 01019 { 01020 return 1; 01021 } 01022 01023 /** Set pos_left_elbow_confidence value. 01024 * 01025 Left elbow position confidence. 01026 * @param new_pos_left_elbow_confidence new pos_left_elbow_confidence value 01027 */ 01028 void 01029 HumanSkeletonInterface::set_pos_left_elbow_confidence(const float new_pos_left_elbow_confidence) 01030 { 01031 data->pos_left_elbow_confidence = new_pos_left_elbow_confidence; 01032 data_changed = true; 01033 } 01034 01035 /** Get pos_left_wrist value. 01036 * 01037 Left wrist position vector. 01038 * @return pos_left_wrist value 01039 */ 01040 float * 01041 HumanSkeletonInterface::pos_left_wrist() const 01042 { 01043 return data->pos_left_wrist; 01044 } 01045 01046 /** Get pos_left_wrist value at given index. 01047 * 01048 Left wrist position vector. 01049 * @param index index of value 01050 * @return pos_left_wrist value 01051 * @exception Exception thrown if index is out of bounds 01052 */ 01053 float 01054 HumanSkeletonInterface::pos_left_wrist(unsigned int index) const 01055 { 01056 if (index > 3) { 01057 throw Exception("Index value %u out of bounds (0..3)", index); 01058 } 01059 return data->pos_left_wrist[index]; 01060 } 01061 01062 /** Get maximum length of pos_left_wrist value. 01063 * @return length of pos_left_wrist value, can be length of the array or number of 01064 * maximum number of characters for a string 01065 */ 01066 size_t 01067 HumanSkeletonInterface::maxlenof_pos_left_wrist() const 01068 { 01069 return 3; 01070 } 01071 01072 /** Set pos_left_wrist value. 01073 * 01074 Left wrist position vector. 01075 * @param new_pos_left_wrist new pos_left_wrist value 01076 */ 01077 void 01078 HumanSkeletonInterface::set_pos_left_wrist(const float * new_pos_left_wrist) 01079 { 01080 memcpy(data->pos_left_wrist, new_pos_left_wrist, sizeof(float) * 3); 01081 data_changed = true; 01082 } 01083 01084 /** Set pos_left_wrist value at given index. 01085 * 01086 Left wrist position vector. 01087 * @param new_pos_left_wrist new pos_left_wrist value 01088 * @param index index for of the value 01089 */ 01090 void 01091 HumanSkeletonInterface::set_pos_left_wrist(unsigned int index, const float new_pos_left_wrist) 01092 { 01093 if (index > 3) { 01094 throw Exception("Index value %u out of bounds (0..3)", index); 01095 } 01096 data->pos_left_wrist[index] = new_pos_left_wrist; 01097 data_changed = true; 01098 } 01099 /** Get pos_left_wrist_confidence value. 01100 * 01101 Left wrist position confidence. 01102 * @return pos_left_wrist_confidence value 01103 */ 01104 float 01105 HumanSkeletonInterface::pos_left_wrist_confidence() const 01106 { 01107 return data->pos_left_wrist_confidence; 01108 } 01109 01110 /** Get maximum length of pos_left_wrist_confidence value. 01111 * @return length of pos_left_wrist_confidence value, can be length of the array or number of 01112 * maximum number of characters for a string 01113 */ 01114 size_t 01115 HumanSkeletonInterface::maxlenof_pos_left_wrist_confidence() const 01116 { 01117 return 1; 01118 } 01119 01120 /** Set pos_left_wrist_confidence value. 01121 * 01122 Left wrist position confidence. 01123 * @param new_pos_left_wrist_confidence new pos_left_wrist_confidence value 01124 */ 01125 void 01126 HumanSkeletonInterface::set_pos_left_wrist_confidence(const float new_pos_left_wrist_confidence) 01127 { 01128 data->pos_left_wrist_confidence = new_pos_left_wrist_confidence; 01129 data_changed = true; 01130 } 01131 01132 /** Get pos_left_hand value. 01133 * 01134 Left hand position vector. 01135 * @return pos_left_hand value 01136 */ 01137 float * 01138 HumanSkeletonInterface::pos_left_hand() const 01139 { 01140 return data->pos_left_hand; 01141 } 01142 01143 /** Get pos_left_hand value at given index. 01144 * 01145 Left hand position vector. 01146 * @param index index of value 01147 * @return pos_left_hand value 01148 * @exception Exception thrown if index is out of bounds 01149 */ 01150 float 01151 HumanSkeletonInterface::pos_left_hand(unsigned int index) const 01152 { 01153 if (index > 3) { 01154 throw Exception("Index value %u out of bounds (0..3)", index); 01155 } 01156 return data->pos_left_hand[index]; 01157 } 01158 01159 /** Get maximum length of pos_left_hand value. 01160 * @return length of pos_left_hand value, can be length of the array or number of 01161 * maximum number of characters for a string 01162 */ 01163 size_t 01164 HumanSkeletonInterface::maxlenof_pos_left_hand() const 01165 { 01166 return 3; 01167 } 01168 01169 /** Set pos_left_hand value. 01170 * 01171 Left hand position vector. 01172 * @param new_pos_left_hand new pos_left_hand value 01173 */ 01174 void 01175 HumanSkeletonInterface::set_pos_left_hand(const float * new_pos_left_hand) 01176 { 01177 memcpy(data->pos_left_hand, new_pos_left_hand, sizeof(float) * 3); 01178 data_changed = true; 01179 } 01180 01181 /** Set pos_left_hand value at given index. 01182 * 01183 Left hand position vector. 01184 * @param new_pos_left_hand new pos_left_hand value 01185 * @param index index for of the value 01186 */ 01187 void 01188 HumanSkeletonInterface::set_pos_left_hand(unsigned int index, const float new_pos_left_hand) 01189 { 01190 if (index > 3) { 01191 throw Exception("Index value %u out of bounds (0..3)", index); 01192 } 01193 data->pos_left_hand[index] = new_pos_left_hand; 01194 data_changed = true; 01195 } 01196 /** Get pos_left_hand_confidence value. 01197 * 01198 Left hand position confidence. 01199 * @return pos_left_hand_confidence value 01200 */ 01201 float 01202 HumanSkeletonInterface::pos_left_hand_confidence() const 01203 { 01204 return data->pos_left_hand_confidence; 01205 } 01206 01207 /** Get maximum length of pos_left_hand_confidence value. 01208 * @return length of pos_left_hand_confidence value, can be length of the array or number of 01209 * maximum number of characters for a string 01210 */ 01211 size_t 01212 HumanSkeletonInterface::maxlenof_pos_left_hand_confidence() const 01213 { 01214 return 1; 01215 } 01216 01217 /** Set pos_left_hand_confidence value. 01218 * 01219 Left hand position confidence. 01220 * @param new_pos_left_hand_confidence new pos_left_hand_confidence value 01221 */ 01222 void 01223 HumanSkeletonInterface::set_pos_left_hand_confidence(const float new_pos_left_hand_confidence) 01224 { 01225 data->pos_left_hand_confidence = new_pos_left_hand_confidence; 01226 data_changed = true; 01227 } 01228 01229 /** Get pos_left_fingertip value. 01230 * 01231 Left fingertip position vector. 01232 * @return pos_left_fingertip value 01233 */ 01234 float * 01235 HumanSkeletonInterface::pos_left_fingertip() const 01236 { 01237 return data->pos_left_fingertip; 01238 } 01239 01240 /** Get pos_left_fingertip value at given index. 01241 * 01242 Left fingertip position vector. 01243 * @param index index of value 01244 * @return pos_left_fingertip value 01245 * @exception Exception thrown if index is out of bounds 01246 */ 01247 float 01248 HumanSkeletonInterface::pos_left_fingertip(unsigned int index) const 01249 { 01250 if (index > 3) { 01251 throw Exception("Index value %u out of bounds (0..3)", index); 01252 } 01253 return data->pos_left_fingertip[index]; 01254 } 01255 01256 /** Get maximum length of pos_left_fingertip value. 01257 * @return length of pos_left_fingertip value, can be length of the array or number of 01258 * maximum number of characters for a string 01259 */ 01260 size_t 01261 HumanSkeletonInterface::maxlenof_pos_left_fingertip() const 01262 { 01263 return 3; 01264 } 01265 01266 /** Set pos_left_fingertip value. 01267 * 01268 Left fingertip position vector. 01269 * @param new_pos_left_fingertip new pos_left_fingertip value 01270 */ 01271 void 01272 HumanSkeletonInterface::set_pos_left_fingertip(const float * new_pos_left_fingertip) 01273 { 01274 memcpy(data->pos_left_fingertip, new_pos_left_fingertip, sizeof(float) * 3); 01275 data_changed = true; 01276 } 01277 01278 /** Set pos_left_fingertip value at given index. 01279 * 01280 Left fingertip position vector. 01281 * @param new_pos_left_fingertip new pos_left_fingertip value 01282 * @param index index for of the value 01283 */ 01284 void 01285 HumanSkeletonInterface::set_pos_left_fingertip(unsigned int index, const float new_pos_left_fingertip) 01286 { 01287 if (index > 3) { 01288 throw Exception("Index value %u out of bounds (0..3)", index); 01289 } 01290 data->pos_left_fingertip[index] = new_pos_left_fingertip; 01291 data_changed = true; 01292 } 01293 /** Get pos_left_fingertip_confidence value. 01294 * 01295 Left fingertip position confidence. 01296 * @return pos_left_fingertip_confidence value 01297 */ 01298 float 01299 HumanSkeletonInterface::pos_left_fingertip_confidence() const 01300 { 01301 return data->pos_left_fingertip_confidence; 01302 } 01303 01304 /** Get maximum length of pos_left_fingertip_confidence value. 01305 * @return length of pos_left_fingertip_confidence value, can be length of the array or number of 01306 * maximum number of characters for a string 01307 */ 01308 size_t 01309 HumanSkeletonInterface::maxlenof_pos_left_fingertip_confidence() const 01310 { 01311 return 1; 01312 } 01313 01314 /** Set pos_left_fingertip_confidence value. 01315 * 01316 Left fingertip position confidence. 01317 * @param new_pos_left_fingertip_confidence new pos_left_fingertip_confidence value 01318 */ 01319 void 01320 HumanSkeletonInterface::set_pos_left_fingertip_confidence(const float new_pos_left_fingertip_confidence) 01321 { 01322 data->pos_left_fingertip_confidence = new_pos_left_fingertip_confidence; 01323 data_changed = true; 01324 } 01325 01326 /** Get pos_right_collar value. 01327 * 01328 Right collar position vector. 01329 * @return pos_right_collar value 01330 */ 01331 float * 01332 HumanSkeletonInterface::pos_right_collar() const 01333 { 01334 return data->pos_right_collar; 01335 } 01336 01337 /** Get pos_right_collar value at given index. 01338 * 01339 Right collar position vector. 01340 * @param index index of value 01341 * @return pos_right_collar value 01342 * @exception Exception thrown if index is out of bounds 01343 */ 01344 float 01345 HumanSkeletonInterface::pos_right_collar(unsigned int index) const 01346 { 01347 if (index > 3) { 01348 throw Exception("Index value %u out of bounds (0..3)", index); 01349 } 01350 return data->pos_right_collar[index]; 01351 } 01352 01353 /** Get maximum length of pos_right_collar value. 01354 * @return length of pos_right_collar value, can be length of the array or number of 01355 * maximum number of characters for a string 01356 */ 01357 size_t 01358 HumanSkeletonInterface::maxlenof_pos_right_collar() const 01359 { 01360 return 3; 01361 } 01362 01363 /** Set pos_right_collar value. 01364 * 01365 Right collar position vector. 01366 * @param new_pos_right_collar new pos_right_collar value 01367 */ 01368 void 01369 HumanSkeletonInterface::set_pos_right_collar(const float * new_pos_right_collar) 01370 { 01371 memcpy(data->pos_right_collar, new_pos_right_collar, sizeof(float) * 3); 01372 data_changed = true; 01373 } 01374 01375 /** Set pos_right_collar value at given index. 01376 * 01377 Right collar position vector. 01378 * @param new_pos_right_collar new pos_right_collar value 01379 * @param index index for of the value 01380 */ 01381 void 01382 HumanSkeletonInterface::set_pos_right_collar(unsigned int index, const float new_pos_right_collar) 01383 { 01384 if (index > 3) { 01385 throw Exception("Index value %u out of bounds (0..3)", index); 01386 } 01387 data->pos_right_collar[index] = new_pos_right_collar; 01388 data_changed = true; 01389 } 01390 /** Get pos_right_collar_confidence value. 01391 * 01392 Right collar position confidence. 01393 * @return pos_right_collar_confidence value 01394 */ 01395 float 01396 HumanSkeletonInterface::pos_right_collar_confidence() const 01397 { 01398 return data->pos_right_collar_confidence; 01399 } 01400 01401 /** Get maximum length of pos_right_collar_confidence value. 01402 * @return length of pos_right_collar_confidence value, can be length of the array or number of 01403 * maximum number of characters for a string 01404 */ 01405 size_t 01406 HumanSkeletonInterface::maxlenof_pos_right_collar_confidence() const 01407 { 01408 return 1; 01409 } 01410 01411 /** Set pos_right_collar_confidence value. 01412 * 01413 Right collar position confidence. 01414 * @param new_pos_right_collar_confidence new pos_right_collar_confidence value 01415 */ 01416 void 01417 HumanSkeletonInterface::set_pos_right_collar_confidence(const float new_pos_right_collar_confidence) 01418 { 01419 data->pos_right_collar_confidence = new_pos_right_collar_confidence; 01420 data_changed = true; 01421 } 01422 01423 /** Get pos_right_shoulder value. 01424 * 01425 Right shoulder position vector. 01426 * @return pos_right_shoulder value 01427 */ 01428 float * 01429 HumanSkeletonInterface::pos_right_shoulder() const 01430 { 01431 return data->pos_right_shoulder; 01432 } 01433 01434 /** Get pos_right_shoulder value at given index. 01435 * 01436 Right shoulder position vector. 01437 * @param index index of value 01438 * @return pos_right_shoulder value 01439 * @exception Exception thrown if index is out of bounds 01440 */ 01441 float 01442 HumanSkeletonInterface::pos_right_shoulder(unsigned int index) const 01443 { 01444 if (index > 3) { 01445 throw Exception("Index value %u out of bounds (0..3)", index); 01446 } 01447 return data->pos_right_shoulder[index]; 01448 } 01449 01450 /** Get maximum length of pos_right_shoulder value. 01451 * @return length of pos_right_shoulder value, can be length of the array or number of 01452 * maximum number of characters for a string 01453 */ 01454 size_t 01455 HumanSkeletonInterface::maxlenof_pos_right_shoulder() const 01456 { 01457 return 3; 01458 } 01459 01460 /** Set pos_right_shoulder value. 01461 * 01462 Right shoulder position vector. 01463 * @param new_pos_right_shoulder new pos_right_shoulder value 01464 */ 01465 void 01466 HumanSkeletonInterface::set_pos_right_shoulder(const float * new_pos_right_shoulder) 01467 { 01468 memcpy(data->pos_right_shoulder, new_pos_right_shoulder, sizeof(float) * 3); 01469 data_changed = true; 01470 } 01471 01472 /** Set pos_right_shoulder value at given index. 01473 * 01474 Right shoulder position vector. 01475 * @param new_pos_right_shoulder new pos_right_shoulder value 01476 * @param index index for of the value 01477 */ 01478 void 01479 HumanSkeletonInterface::set_pos_right_shoulder(unsigned int index, const float new_pos_right_shoulder) 01480 { 01481 if (index > 3) { 01482 throw Exception("Index value %u out of bounds (0..3)", index); 01483 } 01484 data->pos_right_shoulder[index] = new_pos_right_shoulder; 01485 data_changed = true; 01486 } 01487 /** Get pos_right_shoulder_confidence value. 01488 * 01489 Right shoulder position confidence. 01490 * @return pos_right_shoulder_confidence value 01491 */ 01492 float 01493 HumanSkeletonInterface::pos_right_shoulder_confidence() const 01494 { 01495 return data->pos_right_shoulder_confidence; 01496 } 01497 01498 /** Get maximum length of pos_right_shoulder_confidence value. 01499 * @return length of pos_right_shoulder_confidence value, can be length of the array or number of 01500 * maximum number of characters for a string 01501 */ 01502 size_t 01503 HumanSkeletonInterface::maxlenof_pos_right_shoulder_confidence() const 01504 { 01505 return 1; 01506 } 01507 01508 /** Set pos_right_shoulder_confidence value. 01509 * 01510 Right shoulder position confidence. 01511 * @param new_pos_right_shoulder_confidence new pos_right_shoulder_confidence value 01512 */ 01513 void 01514 HumanSkeletonInterface::set_pos_right_shoulder_confidence(const float new_pos_right_shoulder_confidence) 01515 { 01516 data->pos_right_shoulder_confidence = new_pos_right_shoulder_confidence; 01517 data_changed = true; 01518 } 01519 01520 /** Get pos_right_elbow value. 01521 * 01522 Right elbow position vector. 01523 * @return pos_right_elbow value 01524 */ 01525 float * 01526 HumanSkeletonInterface::pos_right_elbow() const 01527 { 01528 return data->pos_right_elbow; 01529 } 01530 01531 /** Get pos_right_elbow value at given index. 01532 * 01533 Right elbow position vector. 01534 * @param index index of value 01535 * @return pos_right_elbow value 01536 * @exception Exception thrown if index is out of bounds 01537 */ 01538 float 01539 HumanSkeletonInterface::pos_right_elbow(unsigned int index) const 01540 { 01541 if (index > 3) { 01542 throw Exception("Index value %u out of bounds (0..3)", index); 01543 } 01544 return data->pos_right_elbow[index]; 01545 } 01546 01547 /** Get maximum length of pos_right_elbow value. 01548 * @return length of pos_right_elbow value, can be length of the array or number of 01549 * maximum number of characters for a string 01550 */ 01551 size_t 01552 HumanSkeletonInterface::maxlenof_pos_right_elbow() const 01553 { 01554 return 3; 01555 } 01556 01557 /** Set pos_right_elbow value. 01558 * 01559 Right elbow position vector. 01560 * @param new_pos_right_elbow new pos_right_elbow value 01561 */ 01562 void 01563 HumanSkeletonInterface::set_pos_right_elbow(const float * new_pos_right_elbow) 01564 { 01565 memcpy(data->pos_right_elbow, new_pos_right_elbow, sizeof(float) * 3); 01566 data_changed = true; 01567 } 01568 01569 /** Set pos_right_elbow value at given index. 01570 * 01571 Right elbow position vector. 01572 * @param new_pos_right_elbow new pos_right_elbow value 01573 * @param index index for of the value 01574 */ 01575 void 01576 HumanSkeletonInterface::set_pos_right_elbow(unsigned int index, const float new_pos_right_elbow) 01577 { 01578 if (index > 3) { 01579 throw Exception("Index value %u out of bounds (0..3)", index); 01580 } 01581 data->pos_right_elbow[index] = new_pos_right_elbow; 01582 data_changed = true; 01583 } 01584 /** Get pos_right_elbow_confidence value. 01585 * 01586 Right elbow position confidence. 01587 * @return pos_right_elbow_confidence value 01588 */ 01589 float 01590 HumanSkeletonInterface::pos_right_elbow_confidence() const 01591 { 01592 return data->pos_right_elbow_confidence; 01593 } 01594 01595 /** Get maximum length of pos_right_elbow_confidence value. 01596 * @return length of pos_right_elbow_confidence value, can be length of the array or number of 01597 * maximum number of characters for a string 01598 */ 01599 size_t 01600 HumanSkeletonInterface::maxlenof_pos_right_elbow_confidence() const 01601 { 01602 return 1; 01603 } 01604 01605 /** Set pos_right_elbow_confidence value. 01606 * 01607 Right elbow position confidence. 01608 * @param new_pos_right_elbow_confidence new pos_right_elbow_confidence value 01609 */ 01610 void 01611 HumanSkeletonInterface::set_pos_right_elbow_confidence(const float new_pos_right_elbow_confidence) 01612 { 01613 data->pos_right_elbow_confidence = new_pos_right_elbow_confidence; 01614 data_changed = true; 01615 } 01616 01617 /** Get pos_right_wrist value. 01618 * 01619 Right wrist position vector. 01620 * @return pos_right_wrist value 01621 */ 01622 float * 01623 HumanSkeletonInterface::pos_right_wrist() const 01624 { 01625 return data->pos_right_wrist; 01626 } 01627 01628 /** Get pos_right_wrist value at given index. 01629 * 01630 Right wrist position vector. 01631 * @param index index of value 01632 * @return pos_right_wrist value 01633 * @exception Exception thrown if index is out of bounds 01634 */ 01635 float 01636 HumanSkeletonInterface::pos_right_wrist(unsigned int index) const 01637 { 01638 if (index > 3) { 01639 throw Exception("Index value %u out of bounds (0..3)", index); 01640 } 01641 return data->pos_right_wrist[index]; 01642 } 01643 01644 /** Get maximum length of pos_right_wrist value. 01645 * @return length of pos_right_wrist value, can be length of the array or number of 01646 * maximum number of characters for a string 01647 */ 01648 size_t 01649 HumanSkeletonInterface::maxlenof_pos_right_wrist() const 01650 { 01651 return 3; 01652 } 01653 01654 /** Set pos_right_wrist value. 01655 * 01656 Right wrist position vector. 01657 * @param new_pos_right_wrist new pos_right_wrist value 01658 */ 01659 void 01660 HumanSkeletonInterface::set_pos_right_wrist(const float * new_pos_right_wrist) 01661 { 01662 memcpy(data->pos_right_wrist, new_pos_right_wrist, sizeof(float) * 3); 01663 data_changed = true; 01664 } 01665 01666 /** Set pos_right_wrist value at given index. 01667 * 01668 Right wrist position vector. 01669 * @param new_pos_right_wrist new pos_right_wrist value 01670 * @param index index for of the value 01671 */ 01672 void 01673 HumanSkeletonInterface::set_pos_right_wrist(unsigned int index, const float new_pos_right_wrist) 01674 { 01675 if (index > 3) { 01676 throw Exception("Index value %u out of bounds (0..3)", index); 01677 } 01678 data->pos_right_wrist[index] = new_pos_right_wrist; 01679 data_changed = true; 01680 } 01681 /** Get pos_right_wrist_confidence value. 01682 * 01683 Right wrist position confidence. 01684 * @return pos_right_wrist_confidence value 01685 */ 01686 float 01687 HumanSkeletonInterface::pos_right_wrist_confidence() const 01688 { 01689 return data->pos_right_wrist_confidence; 01690 } 01691 01692 /** Get maximum length of pos_right_wrist_confidence value. 01693 * @return length of pos_right_wrist_confidence value, can be length of the array or number of 01694 * maximum number of characters for a string 01695 */ 01696 size_t 01697 HumanSkeletonInterface::maxlenof_pos_right_wrist_confidence() const 01698 { 01699 return 1; 01700 } 01701 01702 /** Set pos_right_wrist_confidence value. 01703 * 01704 Right wrist position confidence. 01705 * @param new_pos_right_wrist_confidence new pos_right_wrist_confidence value 01706 */ 01707 void 01708 HumanSkeletonInterface::set_pos_right_wrist_confidence(const float new_pos_right_wrist_confidence) 01709 { 01710 data->pos_right_wrist_confidence = new_pos_right_wrist_confidence; 01711 data_changed = true; 01712 } 01713 01714 /** Get pos_right_hand value. 01715 * 01716 Right hand position vector. 01717 * @return pos_right_hand value 01718 */ 01719 float * 01720 HumanSkeletonInterface::pos_right_hand() const 01721 { 01722 return data->pos_right_hand; 01723 } 01724 01725 /** Get pos_right_hand value at given index. 01726 * 01727 Right hand position vector. 01728 * @param index index of value 01729 * @return pos_right_hand value 01730 * @exception Exception thrown if index is out of bounds 01731 */ 01732 float 01733 HumanSkeletonInterface::pos_right_hand(unsigned int index) const 01734 { 01735 if (index > 3) { 01736 throw Exception("Index value %u out of bounds (0..3)", index); 01737 } 01738 return data->pos_right_hand[index]; 01739 } 01740 01741 /** Get maximum length of pos_right_hand value. 01742 * @return length of pos_right_hand value, can be length of the array or number of 01743 * maximum number of characters for a string 01744 */ 01745 size_t 01746 HumanSkeletonInterface::maxlenof_pos_right_hand() const 01747 { 01748 return 3; 01749 } 01750 01751 /** Set pos_right_hand value. 01752 * 01753 Right hand position vector. 01754 * @param new_pos_right_hand new pos_right_hand value 01755 */ 01756 void 01757 HumanSkeletonInterface::set_pos_right_hand(const float * new_pos_right_hand) 01758 { 01759 memcpy(data->pos_right_hand, new_pos_right_hand, sizeof(float) * 3); 01760 data_changed = true; 01761 } 01762 01763 /** Set pos_right_hand value at given index. 01764 * 01765 Right hand position vector. 01766 * @param new_pos_right_hand new pos_right_hand value 01767 * @param index index for of the value 01768 */ 01769 void 01770 HumanSkeletonInterface::set_pos_right_hand(unsigned int index, const float new_pos_right_hand) 01771 { 01772 if (index > 3) { 01773 throw Exception("Index value %u out of bounds (0..3)", index); 01774 } 01775 data->pos_right_hand[index] = new_pos_right_hand; 01776 data_changed = true; 01777 } 01778 /** Get pos_right_hand_confidence value. 01779 * 01780 Right hand position confidence. 01781 * @return pos_right_hand_confidence value 01782 */ 01783 float 01784 HumanSkeletonInterface::pos_right_hand_confidence() const 01785 { 01786 return data->pos_right_hand_confidence; 01787 } 01788 01789 /** Get maximum length of pos_right_hand_confidence value. 01790 * @return length of pos_right_hand_confidence value, can be length of the array or number of 01791 * maximum number of characters for a string 01792 */ 01793 size_t 01794 HumanSkeletonInterface::maxlenof_pos_right_hand_confidence() const 01795 { 01796 return 1; 01797 } 01798 01799 /** Set pos_right_hand_confidence value. 01800 * 01801 Right hand position confidence. 01802 * @param new_pos_right_hand_confidence new pos_right_hand_confidence value 01803 */ 01804 void 01805 HumanSkeletonInterface::set_pos_right_hand_confidence(const float new_pos_right_hand_confidence) 01806 { 01807 data->pos_right_hand_confidence = new_pos_right_hand_confidence; 01808 data_changed = true; 01809 } 01810 01811 /** Get pos_right_fingertip value. 01812 * 01813 Right fingertip position vector. 01814 * @return pos_right_fingertip value 01815 */ 01816 float * 01817 HumanSkeletonInterface::pos_right_fingertip() const 01818 { 01819 return data->pos_right_fingertip; 01820 } 01821 01822 /** Get pos_right_fingertip value at given index. 01823 * 01824 Right fingertip position vector. 01825 * @param index index of value 01826 * @return pos_right_fingertip value 01827 * @exception Exception thrown if index is out of bounds 01828 */ 01829 float 01830 HumanSkeletonInterface::pos_right_fingertip(unsigned int index) const 01831 { 01832 if (index > 3) { 01833 throw Exception("Index value %u out of bounds (0..3)", index); 01834 } 01835 return data->pos_right_fingertip[index]; 01836 } 01837 01838 /** Get maximum length of pos_right_fingertip value. 01839 * @return length of pos_right_fingertip value, can be length of the array or number of 01840 * maximum number of characters for a string 01841 */ 01842 size_t 01843 HumanSkeletonInterface::maxlenof_pos_right_fingertip() const 01844 { 01845 return 3; 01846 } 01847 01848 /** Set pos_right_fingertip value. 01849 * 01850 Right fingertip position vector. 01851 * @param new_pos_right_fingertip new pos_right_fingertip value 01852 */ 01853 void 01854 HumanSkeletonInterface::set_pos_right_fingertip(const float * new_pos_right_fingertip) 01855 { 01856 memcpy(data->pos_right_fingertip, new_pos_right_fingertip, sizeof(float) * 3); 01857 data_changed = true; 01858 } 01859 01860 /** Set pos_right_fingertip value at given index. 01861 * 01862 Right fingertip position vector. 01863 * @param new_pos_right_fingertip new pos_right_fingertip value 01864 * @param index index for of the value 01865 */ 01866 void 01867 HumanSkeletonInterface::set_pos_right_fingertip(unsigned int index, const float new_pos_right_fingertip) 01868 { 01869 if (index > 3) { 01870 throw Exception("Index value %u out of bounds (0..3)", index); 01871 } 01872 data->pos_right_fingertip[index] = new_pos_right_fingertip; 01873 data_changed = true; 01874 } 01875 /** Get pos_right_fingertip_confidence value. 01876 * 01877 Right fingertip position confidence. 01878 * @return pos_right_fingertip_confidence value 01879 */ 01880 float 01881 HumanSkeletonInterface::pos_right_fingertip_confidence() const 01882 { 01883 return data->pos_right_fingertip_confidence; 01884 } 01885 01886 /** Get maximum length of pos_right_fingertip_confidence value. 01887 * @return length of pos_right_fingertip_confidence value, can be length of the array or number of 01888 * maximum number of characters for a string 01889 */ 01890 size_t 01891 HumanSkeletonInterface::maxlenof_pos_right_fingertip_confidence() const 01892 { 01893 return 1; 01894 } 01895 01896 /** Set pos_right_fingertip_confidence value. 01897 * 01898 Right fingertip position confidence. 01899 * @param new_pos_right_fingertip_confidence new pos_right_fingertip_confidence value 01900 */ 01901 void 01902 HumanSkeletonInterface::set_pos_right_fingertip_confidence(const float new_pos_right_fingertip_confidence) 01903 { 01904 data->pos_right_fingertip_confidence = new_pos_right_fingertip_confidence; 01905 data_changed = true; 01906 } 01907 01908 /** Get pos_left_hip value. 01909 * 01910 Left hip position vector. 01911 * @return pos_left_hip value 01912 */ 01913 float * 01914 HumanSkeletonInterface::pos_left_hip() const 01915 { 01916 return data->pos_left_hip; 01917 } 01918 01919 /** Get pos_left_hip value at given index. 01920 * 01921 Left hip position vector. 01922 * @param index index of value 01923 * @return pos_left_hip value 01924 * @exception Exception thrown if index is out of bounds 01925 */ 01926 float 01927 HumanSkeletonInterface::pos_left_hip(unsigned int index) const 01928 { 01929 if (index > 3) { 01930 throw Exception("Index value %u out of bounds (0..3)", index); 01931 } 01932 return data->pos_left_hip[index]; 01933 } 01934 01935 /** Get maximum length of pos_left_hip value. 01936 * @return length of pos_left_hip value, can be length of the array or number of 01937 * maximum number of characters for a string 01938 */ 01939 size_t 01940 HumanSkeletonInterface::maxlenof_pos_left_hip() const 01941 { 01942 return 3; 01943 } 01944 01945 /** Set pos_left_hip value. 01946 * 01947 Left hip position vector. 01948 * @param new_pos_left_hip new pos_left_hip value 01949 */ 01950 void 01951 HumanSkeletonInterface::set_pos_left_hip(const float * new_pos_left_hip) 01952 { 01953 memcpy(data->pos_left_hip, new_pos_left_hip, sizeof(float) * 3); 01954 data_changed = true; 01955 } 01956 01957 /** Set pos_left_hip value at given index. 01958 * 01959 Left hip position vector. 01960 * @param new_pos_left_hip new pos_left_hip value 01961 * @param index index for of the value 01962 */ 01963 void 01964 HumanSkeletonInterface::set_pos_left_hip(unsigned int index, const float new_pos_left_hip) 01965 { 01966 if (index > 3) { 01967 throw Exception("Index value %u out of bounds (0..3)", index); 01968 } 01969 data->pos_left_hip[index] = new_pos_left_hip; 01970 data_changed = true; 01971 } 01972 /** Get pos_left_hip_confidence value. 01973 * 01974 Left hip position confidence. 01975 * @return pos_left_hip_confidence value 01976 */ 01977 float 01978 HumanSkeletonInterface::pos_left_hip_confidence() const 01979 { 01980 return data->pos_left_hip_confidence; 01981 } 01982 01983 /** Get maximum length of pos_left_hip_confidence value. 01984 * @return length of pos_left_hip_confidence value, can be length of the array or number of 01985 * maximum number of characters for a string 01986 */ 01987 size_t 01988 HumanSkeletonInterface::maxlenof_pos_left_hip_confidence() const 01989 { 01990 return 1; 01991 } 01992 01993 /** Set pos_left_hip_confidence value. 01994 * 01995 Left hip position confidence. 01996 * @param new_pos_left_hip_confidence new pos_left_hip_confidence value 01997 */ 01998 void 01999 HumanSkeletonInterface::set_pos_left_hip_confidence(const float new_pos_left_hip_confidence) 02000 { 02001 data->pos_left_hip_confidence = new_pos_left_hip_confidence; 02002 data_changed = true; 02003 } 02004 02005 /** Get pos_left_knee value. 02006 * 02007 Left knee position vector. 02008 * @return pos_left_knee value 02009 */ 02010 float * 02011 HumanSkeletonInterface::pos_left_knee() const 02012 { 02013 return data->pos_left_knee; 02014 } 02015 02016 /** Get pos_left_knee value at given index. 02017 * 02018 Left knee position vector. 02019 * @param index index of value 02020 * @return pos_left_knee value 02021 * @exception Exception thrown if index is out of bounds 02022 */ 02023 float 02024 HumanSkeletonInterface::pos_left_knee(unsigned int index) const 02025 { 02026 if (index > 3) { 02027 throw Exception("Index value %u out of bounds (0..3)", index); 02028 } 02029 return data->pos_left_knee[index]; 02030 } 02031 02032 /** Get maximum length of pos_left_knee value. 02033 * @return length of pos_left_knee value, can be length of the array or number of 02034 * maximum number of characters for a string 02035 */ 02036 size_t 02037 HumanSkeletonInterface::maxlenof_pos_left_knee() const 02038 { 02039 return 3; 02040 } 02041 02042 /** Set pos_left_knee value. 02043 * 02044 Left knee position vector. 02045 * @param new_pos_left_knee new pos_left_knee value 02046 */ 02047 void 02048 HumanSkeletonInterface::set_pos_left_knee(const float * new_pos_left_knee) 02049 { 02050 memcpy(data->pos_left_knee, new_pos_left_knee, sizeof(float) * 3); 02051 data_changed = true; 02052 } 02053 02054 /** Set pos_left_knee value at given index. 02055 * 02056 Left knee position vector. 02057 * @param new_pos_left_knee new pos_left_knee value 02058 * @param index index for of the value 02059 */ 02060 void 02061 HumanSkeletonInterface::set_pos_left_knee(unsigned int index, const float new_pos_left_knee) 02062 { 02063 if (index > 3) { 02064 throw Exception("Index value %u out of bounds (0..3)", index); 02065 } 02066 data->pos_left_knee[index] = new_pos_left_knee; 02067 data_changed = true; 02068 } 02069 /** Get pos_left_knee_confidence value. 02070 * 02071 Left knee position confidence. 02072 * @return pos_left_knee_confidence value 02073 */ 02074 float 02075 HumanSkeletonInterface::pos_left_knee_confidence() const 02076 { 02077 return data->pos_left_knee_confidence; 02078 } 02079 02080 /** Get maximum length of pos_left_knee_confidence value. 02081 * @return length of pos_left_knee_confidence value, can be length of the array or number of 02082 * maximum number of characters for a string 02083 */ 02084 size_t 02085 HumanSkeletonInterface::maxlenof_pos_left_knee_confidence() const 02086 { 02087 return 1; 02088 } 02089 02090 /** Set pos_left_knee_confidence value. 02091 * 02092 Left knee position confidence. 02093 * @param new_pos_left_knee_confidence new pos_left_knee_confidence value 02094 */ 02095 void 02096 HumanSkeletonInterface::set_pos_left_knee_confidence(const float new_pos_left_knee_confidence) 02097 { 02098 data->pos_left_knee_confidence = new_pos_left_knee_confidence; 02099 data_changed = true; 02100 } 02101 02102 /** Get pos_left_ankle value. 02103 * 02104 Left ankle position vector. 02105 * @return pos_left_ankle value 02106 */ 02107 float * 02108 HumanSkeletonInterface::pos_left_ankle() const 02109 { 02110 return data->pos_left_ankle; 02111 } 02112 02113 /** Get pos_left_ankle value at given index. 02114 * 02115 Left ankle position vector. 02116 * @param index index of value 02117 * @return pos_left_ankle value 02118 * @exception Exception thrown if index is out of bounds 02119 */ 02120 float 02121 HumanSkeletonInterface::pos_left_ankle(unsigned int index) const 02122 { 02123 if (index > 3) { 02124 throw Exception("Index value %u out of bounds (0..3)", index); 02125 } 02126 return data->pos_left_ankle[index]; 02127 } 02128 02129 /** Get maximum length of pos_left_ankle value. 02130 * @return length of pos_left_ankle value, can be length of the array or number of 02131 * maximum number of characters for a string 02132 */ 02133 size_t 02134 HumanSkeletonInterface::maxlenof_pos_left_ankle() const 02135 { 02136 return 3; 02137 } 02138 02139 /** Set pos_left_ankle value. 02140 * 02141 Left ankle position vector. 02142 * @param new_pos_left_ankle new pos_left_ankle value 02143 */ 02144 void 02145 HumanSkeletonInterface::set_pos_left_ankle(const float * new_pos_left_ankle) 02146 { 02147 memcpy(data->pos_left_ankle, new_pos_left_ankle, sizeof(float) * 3); 02148 data_changed = true; 02149 } 02150 02151 /** Set pos_left_ankle value at given index. 02152 * 02153 Left ankle position vector. 02154 * @param new_pos_left_ankle new pos_left_ankle value 02155 * @param index index for of the value 02156 */ 02157 void 02158 HumanSkeletonInterface::set_pos_left_ankle(unsigned int index, const float new_pos_left_ankle) 02159 { 02160 if (index > 3) { 02161 throw Exception("Index value %u out of bounds (0..3)", index); 02162 } 02163 data->pos_left_ankle[index] = new_pos_left_ankle; 02164 data_changed = true; 02165 } 02166 /** Get pos_left_ankle_confidence value. 02167 * 02168 Left ankle position confidence. 02169 * @return pos_left_ankle_confidence value 02170 */ 02171 float 02172 HumanSkeletonInterface::pos_left_ankle_confidence() const 02173 { 02174 return data->pos_left_ankle_confidence; 02175 } 02176 02177 /** Get maximum length of pos_left_ankle_confidence value. 02178 * @return length of pos_left_ankle_confidence value, can be length of the array or number of 02179 * maximum number of characters for a string 02180 */ 02181 size_t 02182 HumanSkeletonInterface::maxlenof_pos_left_ankle_confidence() const 02183 { 02184 return 1; 02185 } 02186 02187 /** Set pos_left_ankle_confidence value. 02188 * 02189 Left ankle position confidence. 02190 * @param new_pos_left_ankle_confidence new pos_left_ankle_confidence value 02191 */ 02192 void 02193 HumanSkeletonInterface::set_pos_left_ankle_confidence(const float new_pos_left_ankle_confidence) 02194 { 02195 data->pos_left_ankle_confidence = new_pos_left_ankle_confidence; 02196 data_changed = true; 02197 } 02198 02199 /** Get pos_left_foot value. 02200 * 02201 Left foot position vector. 02202 * @return pos_left_foot value 02203 */ 02204 float * 02205 HumanSkeletonInterface::pos_left_foot() const 02206 { 02207 return data->pos_left_foot; 02208 } 02209 02210 /** Get pos_left_foot value at given index. 02211 * 02212 Left foot position vector. 02213 * @param index index of value 02214 * @return pos_left_foot value 02215 * @exception Exception thrown if index is out of bounds 02216 */ 02217 float 02218 HumanSkeletonInterface::pos_left_foot(unsigned int index) const 02219 { 02220 if (index > 3) { 02221 throw Exception("Index value %u out of bounds (0..3)", index); 02222 } 02223 return data->pos_left_foot[index]; 02224 } 02225 02226 /** Get maximum length of pos_left_foot value. 02227 * @return length of pos_left_foot value, can be length of the array or number of 02228 * maximum number of characters for a string 02229 */ 02230 size_t 02231 HumanSkeletonInterface::maxlenof_pos_left_foot() const 02232 { 02233 return 3; 02234 } 02235 02236 /** Set pos_left_foot value. 02237 * 02238 Left foot position vector. 02239 * @param new_pos_left_foot new pos_left_foot value 02240 */ 02241 void 02242 HumanSkeletonInterface::set_pos_left_foot(const float * new_pos_left_foot) 02243 { 02244 memcpy(data->pos_left_foot, new_pos_left_foot, sizeof(float) * 3); 02245 data_changed = true; 02246 } 02247 02248 /** Set pos_left_foot value at given index. 02249 * 02250 Left foot position vector. 02251 * @param new_pos_left_foot new pos_left_foot value 02252 * @param index index for of the value 02253 */ 02254 void 02255 HumanSkeletonInterface::set_pos_left_foot(unsigned int index, const float new_pos_left_foot) 02256 { 02257 if (index > 3) { 02258 throw Exception("Index value %u out of bounds (0..3)", index); 02259 } 02260 data->pos_left_foot[index] = new_pos_left_foot; 02261 data_changed = true; 02262 } 02263 /** Get pos_left_foot_confidence value. 02264 * 02265 Left foot position confidence. 02266 * @return pos_left_foot_confidence value 02267 */ 02268 float 02269 HumanSkeletonInterface::pos_left_foot_confidence() const 02270 { 02271 return data->pos_left_foot_confidence; 02272 } 02273 02274 /** Get maximum length of pos_left_foot_confidence value. 02275 * @return length of pos_left_foot_confidence value, can be length of the array or number of 02276 * maximum number of characters for a string 02277 */ 02278 size_t 02279 HumanSkeletonInterface::maxlenof_pos_left_foot_confidence() const 02280 { 02281 return 1; 02282 } 02283 02284 /** Set pos_left_foot_confidence value. 02285 * 02286 Left foot position confidence. 02287 * @param new_pos_left_foot_confidence new pos_left_foot_confidence value 02288 */ 02289 void 02290 HumanSkeletonInterface::set_pos_left_foot_confidence(const float new_pos_left_foot_confidence) 02291 { 02292 data->pos_left_foot_confidence = new_pos_left_foot_confidence; 02293 data_changed = true; 02294 } 02295 02296 /** Get pos_right_hip value. 02297 * 02298 Right hip position vector. 02299 * @return pos_right_hip value 02300 */ 02301 float * 02302 HumanSkeletonInterface::pos_right_hip() const 02303 { 02304 return data->pos_right_hip; 02305 } 02306 02307 /** Get pos_right_hip value at given index. 02308 * 02309 Right hip position vector. 02310 * @param index index of value 02311 * @return pos_right_hip value 02312 * @exception Exception thrown if index is out of bounds 02313 */ 02314 float 02315 HumanSkeletonInterface::pos_right_hip(unsigned int index) const 02316 { 02317 if (index > 3) { 02318 throw Exception("Index value %u out of bounds (0..3)", index); 02319 } 02320 return data->pos_right_hip[index]; 02321 } 02322 02323 /** Get maximum length of pos_right_hip value. 02324 * @return length of pos_right_hip value, can be length of the array or number of 02325 * maximum number of characters for a string 02326 */ 02327 size_t 02328 HumanSkeletonInterface::maxlenof_pos_right_hip() const 02329 { 02330 return 3; 02331 } 02332 02333 /** Set pos_right_hip value. 02334 * 02335 Right hip position vector. 02336 * @param new_pos_right_hip new pos_right_hip value 02337 */ 02338 void 02339 HumanSkeletonInterface::set_pos_right_hip(const float * new_pos_right_hip) 02340 { 02341 memcpy(data->pos_right_hip, new_pos_right_hip, sizeof(float) * 3); 02342 data_changed = true; 02343 } 02344 02345 /** Set pos_right_hip value at given index. 02346 * 02347 Right hip position vector. 02348 * @param new_pos_right_hip new pos_right_hip value 02349 * @param index index for of the value 02350 */ 02351 void 02352 HumanSkeletonInterface::set_pos_right_hip(unsigned int index, const float new_pos_right_hip) 02353 { 02354 if (index > 3) { 02355 throw Exception("Index value %u out of bounds (0..3)", index); 02356 } 02357 data->pos_right_hip[index] = new_pos_right_hip; 02358 data_changed = true; 02359 } 02360 /** Get pos_right_hip_confidence value. 02361 * 02362 Right hip position confidence. 02363 * @return pos_right_hip_confidence value 02364 */ 02365 float 02366 HumanSkeletonInterface::pos_right_hip_confidence() const 02367 { 02368 return data->pos_right_hip_confidence; 02369 } 02370 02371 /** Get maximum length of pos_right_hip_confidence value. 02372 * @return length of pos_right_hip_confidence value, can be length of the array or number of 02373 * maximum number of characters for a string 02374 */ 02375 size_t 02376 HumanSkeletonInterface::maxlenof_pos_right_hip_confidence() const 02377 { 02378 return 1; 02379 } 02380 02381 /** Set pos_right_hip_confidence value. 02382 * 02383 Right hip position confidence. 02384 * @param new_pos_right_hip_confidence new pos_right_hip_confidence value 02385 */ 02386 void 02387 HumanSkeletonInterface::set_pos_right_hip_confidence(const float new_pos_right_hip_confidence) 02388 { 02389 data->pos_right_hip_confidence = new_pos_right_hip_confidence; 02390 data_changed = true; 02391 } 02392 02393 /** Get pos_right_knee value. 02394 * 02395 Right knee position vector. 02396 * @return pos_right_knee value 02397 */ 02398 float * 02399 HumanSkeletonInterface::pos_right_knee() const 02400 { 02401 return data->pos_right_knee; 02402 } 02403 02404 /** Get pos_right_knee value at given index. 02405 * 02406 Right knee position vector. 02407 * @param index index of value 02408 * @return pos_right_knee value 02409 * @exception Exception thrown if index is out of bounds 02410 */ 02411 float 02412 HumanSkeletonInterface::pos_right_knee(unsigned int index) const 02413 { 02414 if (index > 3) { 02415 throw Exception("Index value %u out of bounds (0..3)", index); 02416 } 02417 return data->pos_right_knee[index]; 02418 } 02419 02420 /** Get maximum length of pos_right_knee value. 02421 * @return length of pos_right_knee value, can be length of the array or number of 02422 * maximum number of characters for a string 02423 */ 02424 size_t 02425 HumanSkeletonInterface::maxlenof_pos_right_knee() const 02426 { 02427 return 3; 02428 } 02429 02430 /** Set pos_right_knee value. 02431 * 02432 Right knee position vector. 02433 * @param new_pos_right_knee new pos_right_knee value 02434 */ 02435 void 02436 HumanSkeletonInterface::set_pos_right_knee(const float * new_pos_right_knee) 02437 { 02438 memcpy(data->pos_right_knee, new_pos_right_knee, sizeof(float) * 3); 02439 data_changed = true; 02440 } 02441 02442 /** Set pos_right_knee value at given index. 02443 * 02444 Right knee position vector. 02445 * @param new_pos_right_knee new pos_right_knee value 02446 * @param index index for of the value 02447 */ 02448 void 02449 HumanSkeletonInterface::set_pos_right_knee(unsigned int index, const float new_pos_right_knee) 02450 { 02451 if (index > 3) { 02452 throw Exception("Index value %u out of bounds (0..3)", index); 02453 } 02454 data->pos_right_knee[index] = new_pos_right_knee; 02455 data_changed = true; 02456 } 02457 /** Get pos_right_knee_confidence value. 02458 * 02459 Right knee position confidence. 02460 * @return pos_right_knee_confidence value 02461 */ 02462 float 02463 HumanSkeletonInterface::pos_right_knee_confidence() const 02464 { 02465 return data->pos_right_knee_confidence; 02466 } 02467 02468 /** Get maximum length of pos_right_knee_confidence value. 02469 * @return length of pos_right_knee_confidence value, can be length of the array or number of 02470 * maximum number of characters for a string 02471 */ 02472 size_t 02473 HumanSkeletonInterface::maxlenof_pos_right_knee_confidence() const 02474 { 02475 return 1; 02476 } 02477 02478 /** Set pos_right_knee_confidence value. 02479 * 02480 Right knee position confidence. 02481 * @param new_pos_right_knee_confidence new pos_right_knee_confidence value 02482 */ 02483 void 02484 HumanSkeletonInterface::set_pos_right_knee_confidence(const float new_pos_right_knee_confidence) 02485 { 02486 data->pos_right_knee_confidence = new_pos_right_knee_confidence; 02487 data_changed = true; 02488 } 02489 02490 /** Get pos_right_ankle value. 02491 * 02492 Right ankle position vector. 02493 * @return pos_right_ankle value 02494 */ 02495 float * 02496 HumanSkeletonInterface::pos_right_ankle() const 02497 { 02498 return data->pos_right_ankle; 02499 } 02500 02501 /** Get pos_right_ankle value at given index. 02502 * 02503 Right ankle position vector. 02504 * @param index index of value 02505 * @return pos_right_ankle value 02506 * @exception Exception thrown if index is out of bounds 02507 */ 02508 float 02509 HumanSkeletonInterface::pos_right_ankle(unsigned int index) const 02510 { 02511 if (index > 3) { 02512 throw Exception("Index value %u out of bounds (0..3)", index); 02513 } 02514 return data->pos_right_ankle[index]; 02515 } 02516 02517 /** Get maximum length of pos_right_ankle value. 02518 * @return length of pos_right_ankle value, can be length of the array or number of 02519 * maximum number of characters for a string 02520 */ 02521 size_t 02522 HumanSkeletonInterface::maxlenof_pos_right_ankle() const 02523 { 02524 return 3; 02525 } 02526 02527 /** Set pos_right_ankle value. 02528 * 02529 Right ankle position vector. 02530 * @param new_pos_right_ankle new pos_right_ankle value 02531 */ 02532 void 02533 HumanSkeletonInterface::set_pos_right_ankle(const float * new_pos_right_ankle) 02534 { 02535 memcpy(data->pos_right_ankle, new_pos_right_ankle, sizeof(float) * 3); 02536 data_changed = true; 02537 } 02538 02539 /** Set pos_right_ankle value at given index. 02540 * 02541 Right ankle position vector. 02542 * @param new_pos_right_ankle new pos_right_ankle value 02543 * @param index index for of the value 02544 */ 02545 void 02546 HumanSkeletonInterface::set_pos_right_ankle(unsigned int index, const float new_pos_right_ankle) 02547 { 02548 if (index > 3) { 02549 throw Exception("Index value %u out of bounds (0..3)", index); 02550 } 02551 data->pos_right_ankle[index] = new_pos_right_ankle; 02552 data_changed = true; 02553 } 02554 /** Get pos_right_ankle_confidence value. 02555 * 02556 Right ankle position confidence. 02557 * @return pos_right_ankle_confidence value 02558 */ 02559 float 02560 HumanSkeletonInterface::pos_right_ankle_confidence() const 02561 { 02562 return data->pos_right_ankle_confidence; 02563 } 02564 02565 /** Get maximum length of pos_right_ankle_confidence value. 02566 * @return length of pos_right_ankle_confidence value, can be length of the array or number of 02567 * maximum number of characters for a string 02568 */ 02569 size_t 02570 HumanSkeletonInterface::maxlenof_pos_right_ankle_confidence() const 02571 { 02572 return 1; 02573 } 02574 02575 /** Set pos_right_ankle_confidence value. 02576 * 02577 Right ankle position confidence. 02578 * @param new_pos_right_ankle_confidence new pos_right_ankle_confidence value 02579 */ 02580 void 02581 HumanSkeletonInterface::set_pos_right_ankle_confidence(const float new_pos_right_ankle_confidence) 02582 { 02583 data->pos_right_ankle_confidence = new_pos_right_ankle_confidence; 02584 data_changed = true; 02585 } 02586 02587 /** Get pos_right_foot value. 02588 * 02589 Right foot position vector. 02590 * @return pos_right_foot value 02591 */ 02592 float * 02593 HumanSkeletonInterface::pos_right_foot() const 02594 { 02595 return data->pos_right_foot; 02596 } 02597 02598 /** Get pos_right_foot value at given index. 02599 * 02600 Right foot position vector. 02601 * @param index index of value 02602 * @return pos_right_foot value 02603 * @exception Exception thrown if index is out of bounds 02604 */ 02605 float 02606 HumanSkeletonInterface::pos_right_foot(unsigned int index) const 02607 { 02608 if (index > 3) { 02609 throw Exception("Index value %u out of bounds (0..3)", index); 02610 } 02611 return data->pos_right_foot[index]; 02612 } 02613 02614 /** Get maximum length of pos_right_foot value. 02615 * @return length of pos_right_foot value, can be length of the array or number of 02616 * maximum number of characters for a string 02617 */ 02618 size_t 02619 HumanSkeletonInterface::maxlenof_pos_right_foot() const 02620 { 02621 return 3; 02622 } 02623 02624 /** Set pos_right_foot value. 02625 * 02626 Right foot position vector. 02627 * @param new_pos_right_foot new pos_right_foot value 02628 */ 02629 void 02630 HumanSkeletonInterface::set_pos_right_foot(const float * new_pos_right_foot) 02631 { 02632 memcpy(data->pos_right_foot, new_pos_right_foot, sizeof(float) * 3); 02633 data_changed = true; 02634 } 02635 02636 /** Set pos_right_foot value at given index. 02637 * 02638 Right foot position vector. 02639 * @param new_pos_right_foot new pos_right_foot value 02640 * @param index index for of the value 02641 */ 02642 void 02643 HumanSkeletonInterface::set_pos_right_foot(unsigned int index, const float new_pos_right_foot) 02644 { 02645 if (index > 3) { 02646 throw Exception("Index value %u out of bounds (0..3)", index); 02647 } 02648 data->pos_right_foot[index] = new_pos_right_foot; 02649 data_changed = true; 02650 } 02651 /** Get pos_right_foot_confidence value. 02652 * 02653 Right foot position confidence. 02654 * @return pos_right_foot_confidence value 02655 */ 02656 float 02657 HumanSkeletonInterface::pos_right_foot_confidence() const 02658 { 02659 return data->pos_right_foot_confidence; 02660 } 02661 02662 /** Get maximum length of pos_right_foot_confidence value. 02663 * @return length of pos_right_foot_confidence value, can be length of the array or number of 02664 * maximum number of characters for a string 02665 */ 02666 size_t 02667 HumanSkeletonInterface::maxlenof_pos_right_foot_confidence() const 02668 { 02669 return 1; 02670 } 02671 02672 /** Set pos_right_foot_confidence value. 02673 * 02674 Right foot position confidence. 02675 * @param new_pos_right_foot_confidence new pos_right_foot_confidence value 02676 */ 02677 void 02678 HumanSkeletonInterface::set_pos_right_foot_confidence(const float new_pos_right_foot_confidence) 02679 { 02680 data->pos_right_foot_confidence = new_pos_right_foot_confidence; 02681 data_changed = true; 02682 } 02683 02684 /** Get ori_head value. 02685 * Head position vector. 02686 * @return ori_head value 02687 */ 02688 float * 02689 HumanSkeletonInterface::ori_head() const 02690 { 02691 return data->ori_head; 02692 } 02693 02694 /** Get ori_head value at given index. 02695 * Head position vector. 02696 * @param index index of value 02697 * @return ori_head value 02698 * @exception Exception thrown if index is out of bounds 02699 */ 02700 float 02701 HumanSkeletonInterface::ori_head(unsigned int index) const 02702 { 02703 if (index > 9) { 02704 throw Exception("Index value %u out of bounds (0..9)", index); 02705 } 02706 return data->ori_head[index]; 02707 } 02708 02709 /** Get maximum length of ori_head value. 02710 * @return length of ori_head value, can be length of the array or number of 02711 * maximum number of characters for a string 02712 */ 02713 size_t 02714 HumanSkeletonInterface::maxlenof_ori_head() const 02715 { 02716 return 9; 02717 } 02718 02719 /** Set ori_head value. 02720 * Head position vector. 02721 * @param new_ori_head new ori_head value 02722 */ 02723 void 02724 HumanSkeletonInterface::set_ori_head(const float * new_ori_head) 02725 { 02726 memcpy(data->ori_head, new_ori_head, sizeof(float) * 9); 02727 data_changed = true; 02728 } 02729 02730 /** Set ori_head value at given index. 02731 * Head position vector. 02732 * @param new_ori_head new ori_head value 02733 * @param index index for of the value 02734 */ 02735 void 02736 HumanSkeletonInterface::set_ori_head(unsigned int index, const float new_ori_head) 02737 { 02738 if (index > 9) { 02739 throw Exception("Index value %u out of bounds (0..9)", index); 02740 } 02741 data->ori_head[index] = new_ori_head; 02742 data_changed = true; 02743 } 02744 /** Get ori_head_confidence value. 02745 * 02746 Head position confidence. 02747 * @return ori_head_confidence value 02748 */ 02749 float 02750 HumanSkeletonInterface::ori_head_confidence() const 02751 { 02752 return data->ori_head_confidence; 02753 } 02754 02755 /** Get maximum length of ori_head_confidence value. 02756 * @return length of ori_head_confidence value, can be length of the array or number of 02757 * maximum number of characters for a string 02758 */ 02759 size_t 02760 HumanSkeletonInterface::maxlenof_ori_head_confidence() const 02761 { 02762 return 1; 02763 } 02764 02765 /** Set ori_head_confidence value. 02766 * 02767 Head position confidence. 02768 * @param new_ori_head_confidence new ori_head_confidence value 02769 */ 02770 void 02771 HumanSkeletonInterface::set_ori_head_confidence(const float new_ori_head_confidence) 02772 { 02773 data->ori_head_confidence = new_ori_head_confidence; 02774 data_changed = true; 02775 } 02776 02777 /** Get ori_neck value. 02778 * Neck position vector. 02779 * @return ori_neck value 02780 */ 02781 float * 02782 HumanSkeletonInterface::ori_neck() const 02783 { 02784 return data->ori_neck; 02785 } 02786 02787 /** Get ori_neck value at given index. 02788 * Neck position vector. 02789 * @param index index of value 02790 * @return ori_neck value 02791 * @exception Exception thrown if index is out of bounds 02792 */ 02793 float 02794 HumanSkeletonInterface::ori_neck(unsigned int index) const 02795 { 02796 if (index > 9) { 02797 throw Exception("Index value %u out of bounds (0..9)", index); 02798 } 02799 return data->ori_neck[index]; 02800 } 02801 02802 /** Get maximum length of ori_neck value. 02803 * @return length of ori_neck value, can be length of the array or number of 02804 * maximum number of characters for a string 02805 */ 02806 size_t 02807 HumanSkeletonInterface::maxlenof_ori_neck() const 02808 { 02809 return 9; 02810 } 02811 02812 /** Set ori_neck value. 02813 * Neck position vector. 02814 * @param new_ori_neck new ori_neck value 02815 */ 02816 void 02817 HumanSkeletonInterface::set_ori_neck(const float * new_ori_neck) 02818 { 02819 memcpy(data->ori_neck, new_ori_neck, sizeof(float) * 9); 02820 data_changed = true; 02821 } 02822 02823 /** Set ori_neck value at given index. 02824 * Neck position vector. 02825 * @param new_ori_neck new ori_neck value 02826 * @param index index for of the value 02827 */ 02828 void 02829 HumanSkeletonInterface::set_ori_neck(unsigned int index, const float new_ori_neck) 02830 { 02831 if (index > 9) { 02832 throw Exception("Index value %u out of bounds (0..9)", index); 02833 } 02834 data->ori_neck[index] = new_ori_neck; 02835 data_changed = true; 02836 } 02837 /** Get ori_neck_confidence value. 02838 * 02839 Neck position confidence. 02840 * @return ori_neck_confidence value 02841 */ 02842 float 02843 HumanSkeletonInterface::ori_neck_confidence() const 02844 { 02845 return data->ori_neck_confidence; 02846 } 02847 02848 /** Get maximum length of ori_neck_confidence value. 02849 * @return length of ori_neck_confidence value, can be length of the array or number of 02850 * maximum number of characters for a string 02851 */ 02852 size_t 02853 HumanSkeletonInterface::maxlenof_ori_neck_confidence() const 02854 { 02855 return 1; 02856 } 02857 02858 /** Set ori_neck_confidence value. 02859 * 02860 Neck position confidence. 02861 * @param new_ori_neck_confidence new ori_neck_confidence value 02862 */ 02863 void 02864 HumanSkeletonInterface::set_ori_neck_confidence(const float new_ori_neck_confidence) 02865 { 02866 data->ori_neck_confidence = new_ori_neck_confidence; 02867 data_changed = true; 02868 } 02869 02870 /** Get ori_torso value. 02871 * Torso position vector. 02872 * @return ori_torso value 02873 */ 02874 float * 02875 HumanSkeletonInterface::ori_torso() const 02876 { 02877 return data->ori_torso; 02878 } 02879 02880 /** Get ori_torso value at given index. 02881 * Torso position vector. 02882 * @param index index of value 02883 * @return ori_torso value 02884 * @exception Exception thrown if index is out of bounds 02885 */ 02886 float 02887 HumanSkeletonInterface::ori_torso(unsigned int index) const 02888 { 02889 if (index > 9) { 02890 throw Exception("Index value %u out of bounds (0..9)", index); 02891 } 02892 return data->ori_torso[index]; 02893 } 02894 02895 /** Get maximum length of ori_torso value. 02896 * @return length of ori_torso value, can be length of the array or number of 02897 * maximum number of characters for a string 02898 */ 02899 size_t 02900 HumanSkeletonInterface::maxlenof_ori_torso() const 02901 { 02902 return 9; 02903 } 02904 02905 /** Set ori_torso value. 02906 * Torso position vector. 02907 * @param new_ori_torso new ori_torso value 02908 */ 02909 void 02910 HumanSkeletonInterface::set_ori_torso(const float * new_ori_torso) 02911 { 02912 memcpy(data->ori_torso, new_ori_torso, sizeof(float) * 9); 02913 data_changed = true; 02914 } 02915 02916 /** Set ori_torso value at given index. 02917 * Torso position vector. 02918 * @param new_ori_torso new ori_torso value 02919 * @param index index for of the value 02920 */ 02921 void 02922 HumanSkeletonInterface::set_ori_torso(unsigned int index, const float new_ori_torso) 02923 { 02924 if (index > 9) { 02925 throw Exception("Index value %u out of bounds (0..9)", index); 02926 } 02927 data->ori_torso[index] = new_ori_torso; 02928 data_changed = true; 02929 } 02930 /** Get ori_torso_confidence value. 02931 * 02932 Torso position confidence. 02933 * @return ori_torso_confidence value 02934 */ 02935 float 02936 HumanSkeletonInterface::ori_torso_confidence() const 02937 { 02938 return data->ori_torso_confidence; 02939 } 02940 02941 /** Get maximum length of ori_torso_confidence value. 02942 * @return length of ori_torso_confidence value, can be length of the array or number of 02943 * maximum number of characters for a string 02944 */ 02945 size_t 02946 HumanSkeletonInterface::maxlenof_ori_torso_confidence() const 02947 { 02948 return 1; 02949 } 02950 02951 /** Set ori_torso_confidence value. 02952 * 02953 Torso position confidence. 02954 * @param new_ori_torso_confidence new ori_torso_confidence value 02955 */ 02956 void 02957 HumanSkeletonInterface::set_ori_torso_confidence(const float new_ori_torso_confidence) 02958 { 02959 data->ori_torso_confidence = new_ori_torso_confidence; 02960 data_changed = true; 02961 } 02962 02963 /** Get ori_waist value. 02964 * Waist position vector. 02965 * @return ori_waist value 02966 */ 02967 float * 02968 HumanSkeletonInterface::ori_waist() const 02969 { 02970 return data->ori_waist; 02971 } 02972 02973 /** Get ori_waist value at given index. 02974 * Waist position vector. 02975 * @param index index of value 02976 * @return ori_waist value 02977 * @exception Exception thrown if index is out of bounds 02978 */ 02979 float 02980 HumanSkeletonInterface::ori_waist(unsigned int index) const 02981 { 02982 if (index > 9) { 02983 throw Exception("Index value %u out of bounds (0..9)", index); 02984 } 02985 return data->ori_waist[index]; 02986 } 02987 02988 /** Get maximum length of ori_waist value. 02989 * @return length of ori_waist value, can be length of the array or number of 02990 * maximum number of characters for a string 02991 */ 02992 size_t 02993 HumanSkeletonInterface::maxlenof_ori_waist() const 02994 { 02995 return 9; 02996 } 02997 02998 /** Set ori_waist value. 02999 * Waist position vector. 03000 * @param new_ori_waist new ori_waist value 03001 */ 03002 void 03003 HumanSkeletonInterface::set_ori_waist(const float * new_ori_waist) 03004 { 03005 memcpy(data->ori_waist, new_ori_waist, sizeof(float) * 9); 03006 data_changed = true; 03007 } 03008 03009 /** Set ori_waist value at given index. 03010 * Waist position vector. 03011 * @param new_ori_waist new ori_waist value 03012 * @param index index for of the value 03013 */ 03014 void 03015 HumanSkeletonInterface::set_ori_waist(unsigned int index, const float new_ori_waist) 03016 { 03017 if (index > 9) { 03018 throw Exception("Index value %u out of bounds (0..9)", index); 03019 } 03020 data->ori_waist[index] = new_ori_waist; 03021 data_changed = true; 03022 } 03023 /** Get ori_waist_confidence value. 03024 * 03025 Waist position confidence. 03026 * @return ori_waist_confidence value 03027 */ 03028 float 03029 HumanSkeletonInterface::ori_waist_confidence() const 03030 { 03031 return data->ori_waist_confidence; 03032 } 03033 03034 /** Get maximum length of ori_waist_confidence value. 03035 * @return length of ori_waist_confidence value, can be length of the array or number of 03036 * maximum number of characters for a string 03037 */ 03038 size_t 03039 HumanSkeletonInterface::maxlenof_ori_waist_confidence() const 03040 { 03041 return 1; 03042 } 03043 03044 /** Set ori_waist_confidence value. 03045 * 03046 Waist position confidence. 03047 * @param new_ori_waist_confidence new ori_waist_confidence value 03048 */ 03049 void 03050 HumanSkeletonInterface::set_ori_waist_confidence(const float new_ori_waist_confidence) 03051 { 03052 data->ori_waist_confidence = new_ori_waist_confidence; 03053 data_changed = true; 03054 } 03055 03056 /** Get ori_left_collar value. 03057 * 03058 Left position vector. 03059 * @return ori_left_collar value 03060 */ 03061 float * 03062 HumanSkeletonInterface::ori_left_collar() const 03063 { 03064 return data->ori_left_collar; 03065 } 03066 03067 /** Get ori_left_collar value at given index. 03068 * 03069 Left position vector. 03070 * @param index index of value 03071 * @return ori_left_collar value 03072 * @exception Exception thrown if index is out of bounds 03073 */ 03074 float 03075 HumanSkeletonInterface::ori_left_collar(unsigned int index) const 03076 { 03077 if (index > 9) { 03078 throw Exception("Index value %u out of bounds (0..9)", index); 03079 } 03080 return data->ori_left_collar[index]; 03081 } 03082 03083 /** Get maximum length of ori_left_collar value. 03084 * @return length of ori_left_collar value, can be length of the array or number of 03085 * maximum number of characters for a string 03086 */ 03087 size_t 03088 HumanSkeletonInterface::maxlenof_ori_left_collar() const 03089 { 03090 return 9; 03091 } 03092 03093 /** Set ori_left_collar value. 03094 * 03095 Left position vector. 03096 * @param new_ori_left_collar new ori_left_collar value 03097 */ 03098 void 03099 HumanSkeletonInterface::set_ori_left_collar(const float * new_ori_left_collar) 03100 { 03101 memcpy(data->ori_left_collar, new_ori_left_collar, sizeof(float) * 9); 03102 data_changed = true; 03103 } 03104 03105 /** Set ori_left_collar value at given index. 03106 * 03107 Left position vector. 03108 * @param new_ori_left_collar new ori_left_collar value 03109 * @param index index for of the value 03110 */ 03111 void 03112 HumanSkeletonInterface::set_ori_left_collar(unsigned int index, const float new_ori_left_collar) 03113 { 03114 if (index > 9) { 03115 throw Exception("Index value %u out of bounds (0..9)", index); 03116 } 03117 data->ori_left_collar[index] = new_ori_left_collar; 03118 data_changed = true; 03119 } 03120 /** Get ori_left_collar_confidence value. 03121 * 03122 Left position confidence. 03123 * @return ori_left_collar_confidence value 03124 */ 03125 float 03126 HumanSkeletonInterface::ori_left_collar_confidence() const 03127 { 03128 return data->ori_left_collar_confidence; 03129 } 03130 03131 /** Get maximum length of ori_left_collar_confidence value. 03132 * @return length of ori_left_collar_confidence value, can be length of the array or number of 03133 * maximum number of characters for a string 03134 */ 03135 size_t 03136 HumanSkeletonInterface::maxlenof_ori_left_collar_confidence() const 03137 { 03138 return 1; 03139 } 03140 03141 /** Set ori_left_collar_confidence value. 03142 * 03143 Left position confidence. 03144 * @param new_ori_left_collar_confidence new ori_left_collar_confidence value 03145 */ 03146 void 03147 HumanSkeletonInterface::set_ori_left_collar_confidence(const float new_ori_left_collar_confidence) 03148 { 03149 data->ori_left_collar_confidence = new_ori_left_collar_confidence; 03150 data_changed = true; 03151 } 03152 03153 /** Get ori_left_shoulder value. 03154 * 03155 Left shoulder position vector. 03156 * @return ori_left_shoulder value 03157 */ 03158 float * 03159 HumanSkeletonInterface::ori_left_shoulder() const 03160 { 03161 return data->ori_left_shoulder; 03162 } 03163 03164 /** Get ori_left_shoulder value at given index. 03165 * 03166 Left shoulder position vector. 03167 * @param index index of value 03168 * @return ori_left_shoulder value 03169 * @exception Exception thrown if index is out of bounds 03170 */ 03171 float 03172 HumanSkeletonInterface::ori_left_shoulder(unsigned int index) const 03173 { 03174 if (index > 9) { 03175 throw Exception("Index value %u out of bounds (0..9)", index); 03176 } 03177 return data->ori_left_shoulder[index]; 03178 } 03179 03180 /** Get maximum length of ori_left_shoulder value. 03181 * @return length of ori_left_shoulder value, can be length of the array or number of 03182 * maximum number of characters for a string 03183 */ 03184 size_t 03185 HumanSkeletonInterface::maxlenof_ori_left_shoulder() const 03186 { 03187 return 9; 03188 } 03189 03190 /** Set ori_left_shoulder value. 03191 * 03192 Left shoulder position vector. 03193 * @param new_ori_left_shoulder new ori_left_shoulder value 03194 */ 03195 void 03196 HumanSkeletonInterface::set_ori_left_shoulder(const float * new_ori_left_shoulder) 03197 { 03198 memcpy(data->ori_left_shoulder, new_ori_left_shoulder, sizeof(float) * 9); 03199 data_changed = true; 03200 } 03201 03202 /** Set ori_left_shoulder value at given index. 03203 * 03204 Left shoulder position vector. 03205 * @param new_ori_left_shoulder new ori_left_shoulder value 03206 * @param index index for of the value 03207 */ 03208 void 03209 HumanSkeletonInterface::set_ori_left_shoulder(unsigned int index, const float new_ori_left_shoulder) 03210 { 03211 if (index > 9) { 03212 throw Exception("Index value %u out of bounds (0..9)", index); 03213 } 03214 data->ori_left_shoulder[index] = new_ori_left_shoulder; 03215 data_changed = true; 03216 } 03217 /** Get ori_left_shoulder_confidence value. 03218 * 03219 Left shoulder position confidence. 03220 * @return ori_left_shoulder_confidence value 03221 */ 03222 float 03223 HumanSkeletonInterface::ori_left_shoulder_confidence() const 03224 { 03225 return data->ori_left_shoulder_confidence; 03226 } 03227 03228 /** Get maximum length of ori_left_shoulder_confidence value. 03229 * @return length of ori_left_shoulder_confidence value, can be length of the array or number of 03230 * maximum number of characters for a string 03231 */ 03232 size_t 03233 HumanSkeletonInterface::maxlenof_ori_left_shoulder_confidence() const 03234 { 03235 return 1; 03236 } 03237 03238 /** Set ori_left_shoulder_confidence value. 03239 * 03240 Left shoulder position confidence. 03241 * @param new_ori_left_shoulder_confidence new ori_left_shoulder_confidence value 03242 */ 03243 void 03244 HumanSkeletonInterface::set_ori_left_shoulder_confidence(const float new_ori_left_shoulder_confidence) 03245 { 03246 data->ori_left_shoulder_confidence = new_ori_left_shoulder_confidence; 03247 data_changed = true; 03248 } 03249 03250 /** Get ori_left_elbow value. 03251 * 03252 Left elbow position vector. 03253 * @return ori_left_elbow value 03254 */ 03255 float * 03256 HumanSkeletonInterface::ori_left_elbow() const 03257 { 03258 return data->ori_left_elbow; 03259 } 03260 03261 /** Get ori_left_elbow value at given index. 03262 * 03263 Left elbow position vector. 03264 * @param index index of value 03265 * @return ori_left_elbow value 03266 * @exception Exception thrown if index is out of bounds 03267 */ 03268 float 03269 HumanSkeletonInterface::ori_left_elbow(unsigned int index) const 03270 { 03271 if (index > 9) { 03272 throw Exception("Index value %u out of bounds (0..9)", index); 03273 } 03274 return data->ori_left_elbow[index]; 03275 } 03276 03277 /** Get maximum length of ori_left_elbow value. 03278 * @return length of ori_left_elbow value, can be length of the array or number of 03279 * maximum number of characters for a string 03280 */ 03281 size_t 03282 HumanSkeletonInterface::maxlenof_ori_left_elbow() const 03283 { 03284 return 9; 03285 } 03286 03287 /** Set ori_left_elbow value. 03288 * 03289 Left elbow position vector. 03290 * @param new_ori_left_elbow new ori_left_elbow value 03291 */ 03292 void 03293 HumanSkeletonInterface::set_ori_left_elbow(const float * new_ori_left_elbow) 03294 { 03295 memcpy(data->ori_left_elbow, new_ori_left_elbow, sizeof(float) * 9); 03296 data_changed = true; 03297 } 03298 03299 /** Set ori_left_elbow value at given index. 03300 * 03301 Left elbow position vector. 03302 * @param new_ori_left_elbow new ori_left_elbow value 03303 * @param index index for of the value 03304 */ 03305 void 03306 HumanSkeletonInterface::set_ori_left_elbow(unsigned int index, const float new_ori_left_elbow) 03307 { 03308 if (index > 9) { 03309 throw Exception("Index value %u out of bounds (0..9)", index); 03310 } 03311 data->ori_left_elbow[index] = new_ori_left_elbow; 03312 data_changed = true; 03313 } 03314 /** Get ori_left_elbow_confidence value. 03315 * 03316 Left elbow position confidence. 03317 * @return ori_left_elbow_confidence value 03318 */ 03319 float 03320 HumanSkeletonInterface::ori_left_elbow_confidence() const 03321 { 03322 return data->ori_left_elbow_confidence; 03323 } 03324 03325 /** Get maximum length of ori_left_elbow_confidence value. 03326 * @return length of ori_left_elbow_confidence value, can be length of the array or number of 03327 * maximum number of characters for a string 03328 */ 03329 size_t 03330 HumanSkeletonInterface::maxlenof_ori_left_elbow_confidence() const 03331 { 03332 return 1; 03333 } 03334 03335 /** Set ori_left_elbow_confidence value. 03336 * 03337 Left elbow position confidence. 03338 * @param new_ori_left_elbow_confidence new ori_left_elbow_confidence value 03339 */ 03340 void 03341 HumanSkeletonInterface::set_ori_left_elbow_confidence(const float new_ori_left_elbow_confidence) 03342 { 03343 data->ori_left_elbow_confidence = new_ori_left_elbow_confidence; 03344 data_changed = true; 03345 } 03346 03347 /** Get ori_left_wrist value. 03348 * 03349 Left wrist position vector. 03350 * @return ori_left_wrist value 03351 */ 03352 float * 03353 HumanSkeletonInterface::ori_left_wrist() const 03354 { 03355 return data->ori_left_wrist; 03356 } 03357 03358 /** Get ori_left_wrist value at given index. 03359 * 03360 Left wrist position vector. 03361 * @param index index of value 03362 * @return ori_left_wrist value 03363 * @exception Exception thrown if index is out of bounds 03364 */ 03365 float 03366 HumanSkeletonInterface::ori_left_wrist(unsigned int index) const 03367 { 03368 if (index > 9) { 03369 throw Exception("Index value %u out of bounds (0..9)", index); 03370 } 03371 return data->ori_left_wrist[index]; 03372 } 03373 03374 /** Get maximum length of ori_left_wrist value. 03375 * @return length of ori_left_wrist value, can be length of the array or number of 03376 * maximum number of characters for a string 03377 */ 03378 size_t 03379 HumanSkeletonInterface::maxlenof_ori_left_wrist() const 03380 { 03381 return 9; 03382 } 03383 03384 /** Set ori_left_wrist value. 03385 * 03386 Left wrist position vector. 03387 * @param new_ori_left_wrist new ori_left_wrist value 03388 */ 03389 void 03390 HumanSkeletonInterface::set_ori_left_wrist(const float * new_ori_left_wrist) 03391 { 03392 memcpy(data->ori_left_wrist, new_ori_left_wrist, sizeof(float) * 9); 03393 data_changed = true; 03394 } 03395 03396 /** Set ori_left_wrist value at given index. 03397 * 03398 Left wrist position vector. 03399 * @param new_ori_left_wrist new ori_left_wrist value 03400 * @param index index for of the value 03401 */ 03402 void 03403 HumanSkeletonInterface::set_ori_left_wrist(unsigned int index, const float new_ori_left_wrist) 03404 { 03405 if (index > 9) { 03406 throw Exception("Index value %u out of bounds (0..9)", index); 03407 } 03408 data->ori_left_wrist[index] = new_ori_left_wrist; 03409 data_changed = true; 03410 } 03411 /** Get ori_left_wrist_confidence value. 03412 * 03413 Left wrist position confidence. 03414 * @return ori_left_wrist_confidence value 03415 */ 03416 float 03417 HumanSkeletonInterface::ori_left_wrist_confidence() const 03418 { 03419 return data->ori_left_wrist_confidence; 03420 } 03421 03422 /** Get maximum length of ori_left_wrist_confidence value. 03423 * @return length of ori_left_wrist_confidence value, can be length of the array or number of 03424 * maximum number of characters for a string 03425 */ 03426 size_t 03427 HumanSkeletonInterface::maxlenof_ori_left_wrist_confidence() const 03428 { 03429 return 1; 03430 } 03431 03432 /** Set ori_left_wrist_confidence value. 03433 * 03434 Left wrist position confidence. 03435 * @param new_ori_left_wrist_confidence new ori_left_wrist_confidence value 03436 */ 03437 void 03438 HumanSkeletonInterface::set_ori_left_wrist_confidence(const float new_ori_left_wrist_confidence) 03439 { 03440 data->ori_left_wrist_confidence = new_ori_left_wrist_confidence; 03441 data_changed = true; 03442 } 03443 03444 /** Get ori_left_hand value. 03445 * 03446 Left hand position vector. 03447 * @return ori_left_hand value 03448 */ 03449 float * 03450 HumanSkeletonInterface::ori_left_hand() const 03451 { 03452 return data->ori_left_hand; 03453 } 03454 03455 /** Get ori_left_hand value at given index. 03456 * 03457 Left hand position vector. 03458 * @param index index of value 03459 * @return ori_left_hand value 03460 * @exception Exception thrown if index is out of bounds 03461 */ 03462 float 03463 HumanSkeletonInterface::ori_left_hand(unsigned int index) const 03464 { 03465 if (index > 9) { 03466 throw Exception("Index value %u out of bounds (0..9)", index); 03467 } 03468 return data->ori_left_hand[index]; 03469 } 03470 03471 /** Get maximum length of ori_left_hand value. 03472 * @return length of ori_left_hand value, can be length of the array or number of 03473 * maximum number of characters for a string 03474 */ 03475 size_t 03476 HumanSkeletonInterface::maxlenof_ori_left_hand() const 03477 { 03478 return 9; 03479 } 03480 03481 /** Set ori_left_hand value. 03482 * 03483 Left hand position vector. 03484 * @param new_ori_left_hand new ori_left_hand value 03485 */ 03486 void 03487 HumanSkeletonInterface::set_ori_left_hand(const float * new_ori_left_hand) 03488 { 03489 memcpy(data->ori_left_hand, new_ori_left_hand, sizeof(float) * 9); 03490 data_changed = true; 03491 } 03492 03493 /** Set ori_left_hand value at given index. 03494 * 03495 Left hand position vector. 03496 * @param new_ori_left_hand new ori_left_hand value 03497 * @param index index for of the value 03498 */ 03499 void 03500 HumanSkeletonInterface::set_ori_left_hand(unsigned int index, const float new_ori_left_hand) 03501 { 03502 if (index > 9) { 03503 throw Exception("Index value %u out of bounds (0..9)", index); 03504 } 03505 data->ori_left_hand[index] = new_ori_left_hand; 03506 data_changed = true; 03507 } 03508 /** Get ori_left_hand_confidence value. 03509 * 03510 Left hand position confidence. 03511 * @return ori_left_hand_confidence value 03512 */ 03513 float 03514 HumanSkeletonInterface::ori_left_hand_confidence() const 03515 { 03516 return data->ori_left_hand_confidence; 03517 } 03518 03519 /** Get maximum length of ori_left_hand_confidence value. 03520 * @return length of ori_left_hand_confidence value, can be length of the array or number of 03521 * maximum number of characters for a string 03522 */ 03523 size_t 03524 HumanSkeletonInterface::maxlenof_ori_left_hand_confidence() const 03525 { 03526 return 1; 03527 } 03528 03529 /** Set ori_left_hand_confidence value. 03530 * 03531 Left hand position confidence. 03532 * @param new_ori_left_hand_confidence new ori_left_hand_confidence value 03533 */ 03534 void 03535 HumanSkeletonInterface::set_ori_left_hand_confidence(const float new_ori_left_hand_confidence) 03536 { 03537 data->ori_left_hand_confidence = new_ori_left_hand_confidence; 03538 data_changed = true; 03539 } 03540 03541 /** Get ori_left_fingertip value. 03542 * 03543 Left fingertip position vector. 03544 * @return ori_left_fingertip value 03545 */ 03546 float * 03547 HumanSkeletonInterface::ori_left_fingertip() const 03548 { 03549 return data->ori_left_fingertip; 03550 } 03551 03552 /** Get ori_left_fingertip value at given index. 03553 * 03554 Left fingertip position vector. 03555 * @param index index of value 03556 * @return ori_left_fingertip value 03557 * @exception Exception thrown if index is out of bounds 03558 */ 03559 float 03560 HumanSkeletonInterface::ori_left_fingertip(unsigned int index) const 03561 { 03562 if (index > 9) { 03563 throw Exception("Index value %u out of bounds (0..9)", index); 03564 } 03565 return data->ori_left_fingertip[index]; 03566 } 03567 03568 /** Get maximum length of ori_left_fingertip value. 03569 * @return length of ori_left_fingertip value, can be length of the array or number of 03570 * maximum number of characters for a string 03571 */ 03572 size_t 03573 HumanSkeletonInterface::maxlenof_ori_left_fingertip() const 03574 { 03575 return 9; 03576 } 03577 03578 /** Set ori_left_fingertip value. 03579 * 03580 Left fingertip position vector. 03581 * @param new_ori_left_fingertip new ori_left_fingertip value 03582 */ 03583 void 03584 HumanSkeletonInterface::set_ori_left_fingertip(const float * new_ori_left_fingertip) 03585 { 03586 memcpy(data->ori_left_fingertip, new_ori_left_fingertip, sizeof(float) * 9); 03587 data_changed = true; 03588 } 03589 03590 /** Set ori_left_fingertip value at given index. 03591 * 03592 Left fingertip position vector. 03593 * @param new_ori_left_fingertip new ori_left_fingertip value 03594 * @param index index for of the value 03595 */ 03596 void 03597 HumanSkeletonInterface::set_ori_left_fingertip(unsigned int index, const float new_ori_left_fingertip) 03598 { 03599 if (index > 9) { 03600 throw Exception("Index value %u out of bounds (0..9)", index); 03601 } 03602 data->ori_left_fingertip[index] = new_ori_left_fingertip; 03603 data_changed = true; 03604 } 03605 /** Get ori_left_fingertip_confidence value. 03606 * 03607 Left fingertip position confidence. 03608 * @return ori_left_fingertip_confidence value 03609 */ 03610 float 03611 HumanSkeletonInterface::ori_left_fingertip_confidence() const 03612 { 03613 return data->ori_left_fingertip_confidence; 03614 } 03615 03616 /** Get maximum length of ori_left_fingertip_confidence value. 03617 * @return length of ori_left_fingertip_confidence value, can be length of the array or number of 03618 * maximum number of characters for a string 03619 */ 03620 size_t 03621 HumanSkeletonInterface::maxlenof_ori_left_fingertip_confidence() const 03622 { 03623 return 1; 03624 } 03625 03626 /** Set ori_left_fingertip_confidence value. 03627 * 03628 Left fingertip position confidence. 03629 * @param new_ori_left_fingertip_confidence new ori_left_fingertip_confidence value 03630 */ 03631 void 03632 HumanSkeletonInterface::set_ori_left_fingertip_confidence(const float new_ori_left_fingertip_confidence) 03633 { 03634 data->ori_left_fingertip_confidence = new_ori_left_fingertip_confidence; 03635 data_changed = true; 03636 } 03637 03638 /** Get ori_right_collar value. 03639 * 03640 Right collar position vector. 03641 * @return ori_right_collar value 03642 */ 03643 float * 03644 HumanSkeletonInterface::ori_right_collar() const 03645 { 03646 return data->ori_right_collar; 03647 } 03648 03649 /** Get ori_right_collar value at given index. 03650 * 03651 Right collar position vector. 03652 * @param index index of value 03653 * @return ori_right_collar value 03654 * @exception Exception thrown if index is out of bounds 03655 */ 03656 float 03657 HumanSkeletonInterface::ori_right_collar(unsigned int index) const 03658 { 03659 if (index > 9) { 03660 throw Exception("Index value %u out of bounds (0..9)", index); 03661 } 03662 return data->ori_right_collar[index]; 03663 } 03664 03665 /** Get maximum length of ori_right_collar value. 03666 * @return length of ori_right_collar value, can be length of the array or number of 03667 * maximum number of characters for a string 03668 */ 03669 size_t 03670 HumanSkeletonInterface::maxlenof_ori_right_collar() const 03671 { 03672 return 9; 03673 } 03674 03675 /** Set ori_right_collar value. 03676 * 03677 Right collar position vector. 03678 * @param new_ori_right_collar new ori_right_collar value 03679 */ 03680 void 03681 HumanSkeletonInterface::set_ori_right_collar(const float * new_ori_right_collar) 03682 { 03683 memcpy(data->ori_right_collar, new_ori_right_collar, sizeof(float) * 9); 03684 data_changed = true; 03685 } 03686 03687 /** Set ori_right_collar value at given index. 03688 * 03689 Right collar position vector. 03690 * @param new_ori_right_collar new ori_right_collar value 03691 * @param index index for of the value 03692 */ 03693 void 03694 HumanSkeletonInterface::set_ori_right_collar(unsigned int index, const float new_ori_right_collar) 03695 { 03696 if (index > 9) { 03697 throw Exception("Index value %u out of bounds (0..9)", index); 03698 } 03699 data->ori_right_collar[index] = new_ori_right_collar; 03700 data_changed = true; 03701 } 03702 /** Get ori_right_collar_confidence value. 03703 * 03704 Right collar position confidence. 03705 * @return ori_right_collar_confidence value 03706 */ 03707 float 03708 HumanSkeletonInterface::ori_right_collar_confidence() const 03709 { 03710 return data->ori_right_collar_confidence; 03711 } 03712 03713 /** Get maximum length of ori_right_collar_confidence value. 03714 * @return length of ori_right_collar_confidence value, can be length of the array or number of 03715 * maximum number of characters for a string 03716 */ 03717 size_t 03718 HumanSkeletonInterface::maxlenof_ori_right_collar_confidence() const 03719 { 03720 return 1; 03721 } 03722 03723 /** Set ori_right_collar_confidence value. 03724 * 03725 Right collar position confidence. 03726 * @param new_ori_right_collar_confidence new ori_right_collar_confidence value 03727 */ 03728 void 03729 HumanSkeletonInterface::set_ori_right_collar_confidence(const float new_ori_right_collar_confidence) 03730 { 03731 data->ori_right_collar_confidence = new_ori_right_collar_confidence; 03732 data_changed = true; 03733 } 03734 03735 /** Get ori_right_shoulder value. 03736 * 03737 Right shoulder position vector. 03738 * @return ori_right_shoulder value 03739 */ 03740 float * 03741 HumanSkeletonInterface::ori_right_shoulder() const 03742 { 03743 return data->ori_right_shoulder; 03744 } 03745 03746 /** Get ori_right_shoulder value at given index. 03747 * 03748 Right shoulder position vector. 03749 * @param index index of value 03750 * @return ori_right_shoulder value 03751 * @exception Exception thrown if index is out of bounds 03752 */ 03753 float 03754 HumanSkeletonInterface::ori_right_shoulder(unsigned int index) const 03755 { 03756 if (index > 9) { 03757 throw Exception("Index value %u out of bounds (0..9)", index); 03758 } 03759 return data->ori_right_shoulder[index]; 03760 } 03761 03762 /** Get maximum length of ori_right_shoulder value. 03763 * @return length of ori_right_shoulder value, can be length of the array or number of 03764 * maximum number of characters for a string 03765 */ 03766 size_t 03767 HumanSkeletonInterface::maxlenof_ori_right_shoulder() const 03768 { 03769 return 9; 03770 } 03771 03772 /** Set ori_right_shoulder value. 03773 * 03774 Right shoulder position vector. 03775 * @param new_ori_right_shoulder new ori_right_shoulder value 03776 */ 03777 void 03778 HumanSkeletonInterface::set_ori_right_shoulder(const float * new_ori_right_shoulder) 03779 { 03780 memcpy(data->ori_right_shoulder, new_ori_right_shoulder, sizeof(float) * 9); 03781 data_changed = true; 03782 } 03783 03784 /** Set ori_right_shoulder value at given index. 03785 * 03786 Right shoulder position vector. 03787 * @param new_ori_right_shoulder new ori_right_shoulder value 03788 * @param index index for of the value 03789 */ 03790 void 03791 HumanSkeletonInterface::set_ori_right_shoulder(unsigned int index, const float new_ori_right_shoulder) 03792 { 03793 if (index > 9) { 03794 throw Exception("Index value %u out of bounds (0..9)", index); 03795 } 03796 data->ori_right_shoulder[index] = new_ori_right_shoulder; 03797 data_changed = true; 03798 } 03799 /** Get ori_right_shoulder_confidence value. 03800 * 03801 Right shoulder position confidence. 03802 * @return ori_right_shoulder_confidence value 03803 */ 03804 float 03805 HumanSkeletonInterface::ori_right_shoulder_confidence() const 03806 { 03807 return data->ori_right_shoulder_confidence; 03808 } 03809 03810 /** Get maximum length of ori_right_shoulder_confidence value. 03811 * @return length of ori_right_shoulder_confidence value, can be length of the array or number of 03812 * maximum number of characters for a string 03813 */ 03814 size_t 03815 HumanSkeletonInterface::maxlenof_ori_right_shoulder_confidence() const 03816 { 03817 return 1; 03818 } 03819 03820 /** Set ori_right_shoulder_confidence value. 03821 * 03822 Right shoulder position confidence. 03823 * @param new_ori_right_shoulder_confidence new ori_right_shoulder_confidence value 03824 */ 03825 void 03826 HumanSkeletonInterface::set_ori_right_shoulder_confidence(const float new_ori_right_shoulder_confidence) 03827 { 03828 data->ori_right_shoulder_confidence = new_ori_right_shoulder_confidence; 03829 data_changed = true; 03830 } 03831 03832 /** Get ori_right_elbow value. 03833 * 03834 Right elbow position vector. 03835 * @return ori_right_elbow value 03836 */ 03837 float * 03838 HumanSkeletonInterface::ori_right_elbow() const 03839 { 03840 return data->ori_right_elbow; 03841 } 03842 03843 /** Get ori_right_elbow value at given index. 03844 * 03845 Right elbow position vector. 03846 * @param index index of value 03847 * @return ori_right_elbow value 03848 * @exception Exception thrown if index is out of bounds 03849 */ 03850 float 03851 HumanSkeletonInterface::ori_right_elbow(unsigned int index) const 03852 { 03853 if (index > 9) { 03854 throw Exception("Index value %u out of bounds (0..9)", index); 03855 } 03856 return data->ori_right_elbow[index]; 03857 } 03858 03859 /** Get maximum length of ori_right_elbow value. 03860 * @return length of ori_right_elbow value, can be length of the array or number of 03861 * maximum number of characters for a string 03862 */ 03863 size_t 03864 HumanSkeletonInterface::maxlenof_ori_right_elbow() const 03865 { 03866 return 9; 03867 } 03868 03869 /** Set ori_right_elbow value. 03870 * 03871 Right elbow position vector. 03872 * @param new_ori_right_elbow new ori_right_elbow value 03873 */ 03874 void 03875 HumanSkeletonInterface::set_ori_right_elbow(const float * new_ori_right_elbow) 03876 { 03877 memcpy(data->ori_right_elbow, new_ori_right_elbow, sizeof(float) * 9); 03878 data_changed = true; 03879 } 03880 03881 /** Set ori_right_elbow value at given index. 03882 * 03883 Right elbow position vector. 03884 * @param new_ori_right_elbow new ori_right_elbow value 03885 * @param index index for of the value 03886 */ 03887 void 03888 HumanSkeletonInterface::set_ori_right_elbow(unsigned int index, const float new_ori_right_elbow) 03889 { 03890 if (index > 9) { 03891 throw Exception("Index value %u out of bounds (0..9)", index); 03892 } 03893 data->ori_right_elbow[index] = new_ori_right_elbow; 03894 data_changed = true; 03895 } 03896 /** Get ori_right_elbow_confidence value. 03897 * 03898 Right elbow position confidence. 03899 * @return ori_right_elbow_confidence value 03900 */ 03901 float 03902 HumanSkeletonInterface::ori_right_elbow_confidence() const 03903 { 03904 return data->ori_right_elbow_confidence; 03905 } 03906 03907 /** Get maximum length of ori_right_elbow_confidence value. 03908 * @return length of ori_right_elbow_confidence value, can be length of the array or number of 03909 * maximum number of characters for a string 03910 */ 03911 size_t 03912 HumanSkeletonInterface::maxlenof_ori_right_elbow_confidence() const 03913 { 03914 return 1; 03915 } 03916 03917 /** Set ori_right_elbow_confidence value. 03918 * 03919 Right elbow position confidence. 03920 * @param new_ori_right_elbow_confidence new ori_right_elbow_confidence value 03921 */ 03922 void 03923 HumanSkeletonInterface::set_ori_right_elbow_confidence(const float new_ori_right_elbow_confidence) 03924 { 03925 data->ori_right_elbow_confidence = new_ori_right_elbow_confidence; 03926 data_changed = true; 03927 } 03928 03929 /** Get ori_right_wrist value. 03930 * 03931 Right wrist position vector. 03932 * @return ori_right_wrist value 03933 */ 03934 float * 03935 HumanSkeletonInterface::ori_right_wrist() const 03936 { 03937 return data->ori_right_wrist; 03938 } 03939 03940 /** Get ori_right_wrist value at given index. 03941 * 03942 Right wrist position vector. 03943 * @param index index of value 03944 * @return ori_right_wrist value 03945 * @exception Exception thrown if index is out of bounds 03946 */ 03947 float 03948 HumanSkeletonInterface::ori_right_wrist(unsigned int index) const 03949 { 03950 if (index > 9) { 03951 throw Exception("Index value %u out of bounds (0..9)", index); 03952 } 03953 return data->ori_right_wrist[index]; 03954 } 03955 03956 /** Get maximum length of ori_right_wrist value. 03957 * @return length of ori_right_wrist value, can be length of the array or number of 03958 * maximum number of characters for a string 03959 */ 03960 size_t 03961 HumanSkeletonInterface::maxlenof_ori_right_wrist() const 03962 { 03963 return 9; 03964 } 03965 03966 /** Set ori_right_wrist value. 03967 * 03968 Right wrist position vector. 03969 * @param new_ori_right_wrist new ori_right_wrist value 03970 */ 03971 void 03972 HumanSkeletonInterface::set_ori_right_wrist(const float * new_ori_right_wrist) 03973 { 03974 memcpy(data->ori_right_wrist, new_ori_right_wrist, sizeof(float) * 9); 03975 data_changed = true; 03976 } 03977 03978 /** Set ori_right_wrist value at given index. 03979 * 03980 Right wrist position vector. 03981 * @param new_ori_right_wrist new ori_right_wrist value 03982 * @param index index for of the value 03983 */ 03984 void 03985 HumanSkeletonInterface::set_ori_right_wrist(unsigned int index, const float new_ori_right_wrist) 03986 { 03987 if (index > 9) { 03988 throw Exception("Index value %u out of bounds (0..9)", index); 03989 } 03990 data->ori_right_wrist[index] = new_ori_right_wrist; 03991 data_changed = true; 03992 } 03993 /** Get ori_right_wrist_confidence value. 03994 * 03995 Right wrist position confidence. 03996 * @return ori_right_wrist_confidence value 03997 */ 03998 float 03999 HumanSkeletonInterface::ori_right_wrist_confidence() const 04000 { 04001 return data->ori_right_wrist_confidence; 04002 } 04003 04004 /** Get maximum length of ori_right_wrist_confidence value. 04005 * @return length of ori_right_wrist_confidence value, can be length of the array or number of 04006 * maximum number of characters for a string 04007 */ 04008 size_t 04009 HumanSkeletonInterface::maxlenof_ori_right_wrist_confidence() const 04010 { 04011 return 1; 04012 } 04013 04014 /** Set ori_right_wrist_confidence value. 04015 * 04016 Right wrist position confidence. 04017 * @param new_ori_right_wrist_confidence new ori_right_wrist_confidence value 04018 */ 04019 void 04020 HumanSkeletonInterface::set_ori_right_wrist_confidence(const float new_ori_right_wrist_confidence) 04021 { 04022 data->ori_right_wrist_confidence = new_ori_right_wrist_confidence; 04023 data_changed = true; 04024 } 04025 04026 /** Get ori_right_hand value. 04027 * 04028 Right hand position vector. 04029 * @return ori_right_hand value 04030 */ 04031 float * 04032 HumanSkeletonInterface::ori_right_hand() const 04033 { 04034 return data->ori_right_hand; 04035 } 04036 04037 /** Get ori_right_hand value at given index. 04038 * 04039 Right hand position vector. 04040 * @param index index of value 04041 * @return ori_right_hand value 04042 * @exception Exception thrown if index is out of bounds 04043 */ 04044 float 04045 HumanSkeletonInterface::ori_right_hand(unsigned int index) const 04046 { 04047 if (index > 9) { 04048 throw Exception("Index value %u out of bounds (0..9)", index); 04049 } 04050 return data->ori_right_hand[index]; 04051 } 04052 04053 /** Get maximum length of ori_right_hand value. 04054 * @return length of ori_right_hand value, can be length of the array or number of 04055 * maximum number of characters for a string 04056 */ 04057 size_t 04058 HumanSkeletonInterface::maxlenof_ori_right_hand() const 04059 { 04060 return 9; 04061 } 04062 04063 /** Set ori_right_hand value. 04064 * 04065 Right hand position vector. 04066 * @param new_ori_right_hand new ori_right_hand value 04067 */ 04068 void 04069 HumanSkeletonInterface::set_ori_right_hand(const float * new_ori_right_hand) 04070 { 04071 memcpy(data->ori_right_hand, new_ori_right_hand, sizeof(float) * 9); 04072 data_changed = true; 04073 } 04074 04075 /** Set ori_right_hand value at given index. 04076 * 04077 Right hand position vector. 04078 * @param new_ori_right_hand new ori_right_hand value 04079 * @param index index for of the value 04080 */ 04081 void 04082 HumanSkeletonInterface::set_ori_right_hand(unsigned int index, const float new_ori_right_hand) 04083 { 04084 if (index > 9) { 04085 throw Exception("Index value %u out of bounds (0..9)", index); 04086 } 04087 data->ori_right_hand[index] = new_ori_right_hand; 04088 data_changed = true; 04089 } 04090 /** Get ori_right_hand_confidence value. 04091 * 04092 Right hand position confidence. 04093 * @return ori_right_hand_confidence value 04094 */ 04095 float 04096 HumanSkeletonInterface::ori_right_hand_confidence() const 04097 { 04098 return data->ori_right_hand_confidence; 04099 } 04100 04101 /** Get maximum length of ori_right_hand_confidence value. 04102 * @return length of ori_right_hand_confidence value, can be length of the array or number of 04103 * maximum number of characters for a string 04104 */ 04105 size_t 04106 HumanSkeletonInterface::maxlenof_ori_right_hand_confidence() const 04107 { 04108 return 1; 04109 } 04110 04111 /** Set ori_right_hand_confidence value. 04112 * 04113 Right hand position confidence. 04114 * @param new_ori_right_hand_confidence new ori_right_hand_confidence value 04115 */ 04116 void 04117 HumanSkeletonInterface::set_ori_right_hand_confidence(const float new_ori_right_hand_confidence) 04118 { 04119 data->ori_right_hand_confidence = new_ori_right_hand_confidence; 04120 data_changed = true; 04121 } 04122 04123 /** Get ori_right_fingertip value. 04124 * 04125 Right fingertip position vector. 04126 * @return ori_right_fingertip value 04127 */ 04128 float * 04129 HumanSkeletonInterface::ori_right_fingertip() const 04130 { 04131 return data->ori_right_fingertip; 04132 } 04133 04134 /** Get ori_right_fingertip value at given index. 04135 * 04136 Right fingertip position vector. 04137 * @param index index of value 04138 * @return ori_right_fingertip value 04139 * @exception Exception thrown if index is out of bounds 04140 */ 04141 float 04142 HumanSkeletonInterface::ori_right_fingertip(unsigned int index) const 04143 { 04144 if (index > 9) { 04145 throw Exception("Index value %u out of bounds (0..9)", index); 04146 } 04147 return data->ori_right_fingertip[index]; 04148 } 04149 04150 /** Get maximum length of ori_right_fingertip value. 04151 * @return length of ori_right_fingertip value, can be length of the array or number of 04152 * maximum number of characters for a string 04153 */ 04154 size_t 04155 HumanSkeletonInterface::maxlenof_ori_right_fingertip() const 04156 { 04157 return 9; 04158 } 04159 04160 /** Set ori_right_fingertip value. 04161 * 04162 Right fingertip position vector. 04163 * @param new_ori_right_fingertip new ori_right_fingertip value 04164 */ 04165 void 04166 HumanSkeletonInterface::set_ori_right_fingertip(const float * new_ori_right_fingertip) 04167 { 04168 memcpy(data->ori_right_fingertip, new_ori_right_fingertip, sizeof(float) * 9); 04169 data_changed = true; 04170 } 04171 04172 /** Set ori_right_fingertip value at given index. 04173 * 04174 Right fingertip position vector. 04175 * @param new_ori_right_fingertip new ori_right_fingertip value 04176 * @param index index for of the value 04177 */ 04178 void 04179 HumanSkeletonInterface::set_ori_right_fingertip(unsigned int index, const float new_ori_right_fingertip) 04180 { 04181 if (index > 9) { 04182 throw Exception("Index value %u out of bounds (0..9)", index); 04183 } 04184 data->ori_right_fingertip[index] = new_ori_right_fingertip; 04185 data_changed = true; 04186 } 04187 /** Get ori_right_fingertip_confidence value. 04188 * 04189 Right fingertip position confidence. 04190 * @return ori_right_fingertip_confidence value 04191 */ 04192 float 04193 HumanSkeletonInterface::ori_right_fingertip_confidence() const 04194 { 04195 return data->ori_right_fingertip_confidence; 04196 } 04197 04198 /** Get maximum length of ori_right_fingertip_confidence value. 04199 * @return length of ori_right_fingertip_confidence value, can be length of the array or number of 04200 * maximum number of characters for a string 04201 */ 04202 size_t 04203 HumanSkeletonInterface::maxlenof_ori_right_fingertip_confidence() const 04204 { 04205 return 1; 04206 } 04207 04208 /** Set ori_right_fingertip_confidence value. 04209 * 04210 Right fingertip position confidence. 04211 * @param new_ori_right_fingertip_confidence new ori_right_fingertip_confidence value 04212 */ 04213 void 04214 HumanSkeletonInterface::set_ori_right_fingertip_confidence(const float new_ori_right_fingertip_confidence) 04215 { 04216 data->ori_right_fingertip_confidence = new_ori_right_fingertip_confidence; 04217 data_changed = true; 04218 } 04219 04220 /** Get ori_left_hip value. 04221 * 04222 Left hip position vector. 04223 * @return ori_left_hip value 04224 */ 04225 float * 04226 HumanSkeletonInterface::ori_left_hip() const 04227 { 04228 return data->ori_left_hip; 04229 } 04230 04231 /** Get ori_left_hip value at given index. 04232 * 04233 Left hip position vector. 04234 * @param index index of value 04235 * @return ori_left_hip value 04236 * @exception Exception thrown if index is out of bounds 04237 */ 04238 float 04239 HumanSkeletonInterface::ori_left_hip(unsigned int index) const 04240 { 04241 if (index > 9) { 04242 throw Exception("Index value %u out of bounds (0..9)", index); 04243 } 04244 return data->ori_left_hip[index]; 04245 } 04246 04247 /** Get maximum length of ori_left_hip value. 04248 * @return length of ori_left_hip value, can be length of the array or number of 04249 * maximum number of characters for a string 04250 */ 04251 size_t 04252 HumanSkeletonInterface::maxlenof_ori_left_hip() const 04253 { 04254 return 9; 04255 } 04256 04257 /** Set ori_left_hip value. 04258 * 04259 Left hip position vector. 04260 * @param new_ori_left_hip new ori_left_hip value 04261 */ 04262 void 04263 HumanSkeletonInterface::set_ori_left_hip(const float * new_ori_left_hip) 04264 { 04265 memcpy(data->ori_left_hip, new_ori_left_hip, sizeof(float) * 9); 04266 data_changed = true; 04267 } 04268 04269 /** Set ori_left_hip value at given index. 04270 * 04271 Left hip position vector. 04272 * @param new_ori_left_hip new ori_left_hip value 04273 * @param index index for of the value 04274 */ 04275 void 04276 HumanSkeletonInterface::set_ori_left_hip(unsigned int index, const float new_ori_left_hip) 04277 { 04278 if (index > 9) { 04279 throw Exception("Index value %u out of bounds (0..9)", index); 04280 } 04281 data->ori_left_hip[index] = new_ori_left_hip; 04282 data_changed = true; 04283 } 04284 /** Get ori_left_hip_confidence value. 04285 * 04286 Left hip position confidence. 04287 * @return ori_left_hip_confidence value 04288 */ 04289 float 04290 HumanSkeletonInterface::ori_left_hip_confidence() const 04291 { 04292 return data->ori_left_hip_confidence; 04293 } 04294 04295 /** Get maximum length of ori_left_hip_confidence value. 04296 * @return length of ori_left_hip_confidence value, can be length of the array or number of 04297 * maximum number of characters for a string 04298 */ 04299 size_t 04300 HumanSkeletonInterface::maxlenof_ori_left_hip_confidence() const 04301 { 04302 return 1; 04303 } 04304 04305 /** Set ori_left_hip_confidence value. 04306 * 04307 Left hip position confidence. 04308 * @param new_ori_left_hip_confidence new ori_left_hip_confidence value 04309 */ 04310 void 04311 HumanSkeletonInterface::set_ori_left_hip_confidence(const float new_ori_left_hip_confidence) 04312 { 04313 data->ori_left_hip_confidence = new_ori_left_hip_confidence; 04314 data_changed = true; 04315 } 04316 04317 /** Get ori_left_knee value. 04318 * 04319 Left knee position vector. 04320 * @return ori_left_knee value 04321 */ 04322 float * 04323 HumanSkeletonInterface::ori_left_knee() const 04324 { 04325 return data->ori_left_knee; 04326 } 04327 04328 /** Get ori_left_knee value at given index. 04329 * 04330 Left knee position vector. 04331 * @param index index of value 04332 * @return ori_left_knee value 04333 * @exception Exception thrown if index is out of bounds 04334 */ 04335 float 04336 HumanSkeletonInterface::ori_left_knee(unsigned int index) const 04337 { 04338 if (index > 9) { 04339 throw Exception("Index value %u out of bounds (0..9)", index); 04340 } 04341 return data->ori_left_knee[index]; 04342 } 04343 04344 /** Get maximum length of ori_left_knee value. 04345 * @return length of ori_left_knee value, can be length of the array or number of 04346 * maximum number of characters for a string 04347 */ 04348 size_t 04349 HumanSkeletonInterface::maxlenof_ori_left_knee() const 04350 { 04351 return 9; 04352 } 04353 04354 /** Set ori_left_knee value. 04355 * 04356 Left knee position vector. 04357 * @param new_ori_left_knee new ori_left_knee value 04358 */ 04359 void 04360 HumanSkeletonInterface::set_ori_left_knee(const float * new_ori_left_knee) 04361 { 04362 memcpy(data->ori_left_knee, new_ori_left_knee, sizeof(float) * 9); 04363 data_changed = true; 04364 } 04365 04366 /** Set ori_left_knee value at given index. 04367 * 04368 Left knee position vector. 04369 * @param new_ori_left_knee new ori_left_knee value 04370 * @param index index for of the value 04371 */ 04372 void 04373 HumanSkeletonInterface::set_ori_left_knee(unsigned int index, const float new_ori_left_knee) 04374 { 04375 if (index > 9) { 04376 throw Exception("Index value %u out of bounds (0..9)", index); 04377 } 04378 data->ori_left_knee[index] = new_ori_left_knee; 04379 data_changed = true; 04380 } 04381 /** Get ori_left_knee_confidence value. 04382 * 04383 Left knee position confidence. 04384 * @return ori_left_knee_confidence value 04385 */ 04386 float 04387 HumanSkeletonInterface::ori_left_knee_confidence() const 04388 { 04389 return data->ori_left_knee_confidence; 04390 } 04391 04392 /** Get maximum length of ori_left_knee_confidence value. 04393 * @return length of ori_left_knee_confidence value, can be length of the array or number of 04394 * maximum number of characters for a string 04395 */ 04396 size_t 04397 HumanSkeletonInterface::maxlenof_ori_left_knee_confidence() const 04398 { 04399 return 1; 04400 } 04401 04402 /** Set ori_left_knee_confidence value. 04403 * 04404 Left knee position confidence. 04405 * @param new_ori_left_knee_confidence new ori_left_knee_confidence value 04406 */ 04407 void 04408 HumanSkeletonInterface::set_ori_left_knee_confidence(const float new_ori_left_knee_confidence) 04409 { 04410 data->ori_left_knee_confidence = new_ori_left_knee_confidence; 04411 data_changed = true; 04412 } 04413 04414 /** Get ori_left_ankle value. 04415 * 04416 Left ankle position vector. 04417 * @return ori_left_ankle value 04418 */ 04419 float * 04420 HumanSkeletonInterface::ori_left_ankle() const 04421 { 04422 return data->ori_left_ankle; 04423 } 04424 04425 /** Get ori_left_ankle value at given index. 04426 * 04427 Left ankle position vector. 04428 * @param index index of value 04429 * @return ori_left_ankle value 04430 * @exception Exception thrown if index is out of bounds 04431 */ 04432 float 04433 HumanSkeletonInterface::ori_left_ankle(unsigned int index) const 04434 { 04435 if (index > 9) { 04436 throw Exception("Index value %u out of bounds (0..9)", index); 04437 } 04438 return data->ori_left_ankle[index]; 04439 } 04440 04441 /** Get maximum length of ori_left_ankle value. 04442 * @return length of ori_left_ankle value, can be length of the array or number of 04443 * maximum number of characters for a string 04444 */ 04445 size_t 04446 HumanSkeletonInterface::maxlenof_ori_left_ankle() const 04447 { 04448 return 9; 04449 } 04450 04451 /** Set ori_left_ankle value. 04452 * 04453 Left ankle position vector. 04454 * @param new_ori_left_ankle new ori_left_ankle value 04455 */ 04456 void 04457 HumanSkeletonInterface::set_ori_left_ankle(const float * new_ori_left_ankle) 04458 { 04459 memcpy(data->ori_left_ankle, new_ori_left_ankle, sizeof(float) * 9); 04460 data_changed = true; 04461 } 04462 04463 /** Set ori_left_ankle value at given index. 04464 * 04465 Left ankle position vector. 04466 * @param new_ori_left_ankle new ori_left_ankle value 04467 * @param index index for of the value 04468 */ 04469 void 04470 HumanSkeletonInterface::set_ori_left_ankle(unsigned int index, const float new_ori_left_ankle) 04471 { 04472 if (index > 9) { 04473 throw Exception("Index value %u out of bounds (0..9)", index); 04474 } 04475 data->ori_left_ankle[index] = new_ori_left_ankle; 04476 data_changed = true; 04477 } 04478 /** Get ori_left_ankle_confidence value. 04479 * 04480 Left ankle position confidence. 04481 * @return ori_left_ankle_confidence value 04482 */ 04483 float 04484 HumanSkeletonInterface::ori_left_ankle_confidence() const 04485 { 04486 return data->ori_left_ankle_confidence; 04487 } 04488 04489 /** Get maximum length of ori_left_ankle_confidence value. 04490 * @return length of ori_left_ankle_confidence value, can be length of the array or number of 04491 * maximum number of characters for a string 04492 */ 04493 size_t 04494 HumanSkeletonInterface::maxlenof_ori_left_ankle_confidence() const 04495 { 04496 return 1; 04497 } 04498 04499 /** Set ori_left_ankle_confidence value. 04500 * 04501 Left ankle position confidence. 04502 * @param new_ori_left_ankle_confidence new ori_left_ankle_confidence value 04503 */ 04504 void 04505 HumanSkeletonInterface::set_ori_left_ankle_confidence(const float new_ori_left_ankle_confidence) 04506 { 04507 data->ori_left_ankle_confidence = new_ori_left_ankle_confidence; 04508 data_changed = true; 04509 } 04510 04511 /** Get ori_left_foot value. 04512 * 04513 Left foot position vector. 04514 * @return ori_left_foot value 04515 */ 04516 float * 04517 HumanSkeletonInterface::ori_left_foot() const 04518 { 04519 return data->ori_left_foot; 04520 } 04521 04522 /** Get ori_left_foot value at given index. 04523 * 04524 Left foot position vector. 04525 * @param index index of value 04526 * @return ori_left_foot value 04527 * @exception Exception thrown if index is out of bounds 04528 */ 04529 float 04530 HumanSkeletonInterface::ori_left_foot(unsigned int index) const 04531 { 04532 if (index > 9) { 04533 throw Exception("Index value %u out of bounds (0..9)", index); 04534 } 04535 return data->ori_left_foot[index]; 04536 } 04537 04538 /** Get maximum length of ori_left_foot value. 04539 * @return length of ori_left_foot value, can be length of the array or number of 04540 * maximum number of characters for a string 04541 */ 04542 size_t 04543 HumanSkeletonInterface::maxlenof_ori_left_foot() const 04544 { 04545 return 9; 04546 } 04547 04548 /** Set ori_left_foot value. 04549 * 04550 Left foot position vector. 04551 * @param new_ori_left_foot new ori_left_foot value 04552 */ 04553 void 04554 HumanSkeletonInterface::set_ori_left_foot(const float * new_ori_left_foot) 04555 { 04556 memcpy(data->ori_left_foot, new_ori_left_foot, sizeof(float) * 9); 04557 data_changed = true; 04558 } 04559 04560 /** Set ori_left_foot value at given index. 04561 * 04562 Left foot position vector. 04563 * @param new_ori_left_foot new ori_left_foot value 04564 * @param index index for of the value 04565 */ 04566 void 04567 HumanSkeletonInterface::set_ori_left_foot(unsigned int index, const float new_ori_left_foot) 04568 { 04569 if (index > 9) { 04570 throw Exception("Index value %u out of bounds (0..9)", index); 04571 } 04572 data->ori_left_foot[index] = new_ori_left_foot; 04573 data_changed = true; 04574 } 04575 /** Get ori_left_foot_confidence value. 04576 * 04577 Left foot position confidence. 04578 * @return ori_left_foot_confidence value 04579 */ 04580 float 04581 HumanSkeletonInterface::ori_left_foot_confidence() const 04582 { 04583 return data->ori_left_foot_confidence; 04584 } 04585 04586 /** Get maximum length of ori_left_foot_confidence value. 04587 * @return length of ori_left_foot_confidence value, can be length of the array or number of 04588 * maximum number of characters for a string 04589 */ 04590 size_t 04591 HumanSkeletonInterface::maxlenof_ori_left_foot_confidence() const 04592 { 04593 return 1; 04594 } 04595 04596 /** Set ori_left_foot_confidence value. 04597 * 04598 Left foot position confidence. 04599 * @param new_ori_left_foot_confidence new ori_left_foot_confidence value 04600 */ 04601 void 04602 HumanSkeletonInterface::set_ori_left_foot_confidence(const float new_ori_left_foot_confidence) 04603 { 04604 data->ori_left_foot_confidence = new_ori_left_foot_confidence; 04605 data_changed = true; 04606 } 04607 04608 /** Get ori_right_hip value. 04609 * 04610 Right hip position vector. 04611 * @return ori_right_hip value 04612 */ 04613 float * 04614 HumanSkeletonInterface::ori_right_hip() const 04615 { 04616 return data->ori_right_hip; 04617 } 04618 04619 /** Get ori_right_hip value at given index. 04620 * 04621 Right hip position vector. 04622 * @param index index of value 04623 * @return ori_right_hip value 04624 * @exception Exception thrown if index is out of bounds 04625 */ 04626 float 04627 HumanSkeletonInterface::ori_right_hip(unsigned int index) const 04628 { 04629 if (index > 9) { 04630 throw Exception("Index value %u out of bounds (0..9)", index); 04631 } 04632 return data->ori_right_hip[index]; 04633 } 04634 04635 /** Get maximum length of ori_right_hip value. 04636 * @return length of ori_right_hip value, can be length of the array or number of 04637 * maximum number of characters for a string 04638 */ 04639 size_t 04640 HumanSkeletonInterface::maxlenof_ori_right_hip() const 04641 { 04642 return 9; 04643 } 04644 04645 /** Set ori_right_hip value. 04646 * 04647 Right hip position vector. 04648 * @param new_ori_right_hip new ori_right_hip value 04649 */ 04650 void 04651 HumanSkeletonInterface::set_ori_right_hip(const float * new_ori_right_hip) 04652 { 04653 memcpy(data->ori_right_hip, new_ori_right_hip, sizeof(float) * 9); 04654 data_changed = true; 04655 } 04656 04657 /** Set ori_right_hip value at given index. 04658 * 04659 Right hip position vector. 04660 * @param new_ori_right_hip new ori_right_hip value 04661 * @param index index for of the value 04662 */ 04663 void 04664 HumanSkeletonInterface::set_ori_right_hip(unsigned int index, const float new_ori_right_hip) 04665 { 04666 if (index > 9) { 04667 throw Exception("Index value %u out of bounds (0..9)", index); 04668 } 04669 data->ori_right_hip[index] = new_ori_right_hip; 04670 data_changed = true; 04671 } 04672 /** Get ori_right_hip_confidence value. 04673 * 04674 Right hip position confidence. 04675 * @return ori_right_hip_confidence value 04676 */ 04677 float 04678 HumanSkeletonInterface::ori_right_hip_confidence() const 04679 { 04680 return data->ori_right_hip_confidence; 04681 } 04682 04683 /** Get maximum length of ori_right_hip_confidence value. 04684 * @return length of ori_right_hip_confidence value, can be length of the array or number of 04685 * maximum number of characters for a string 04686 */ 04687 size_t 04688 HumanSkeletonInterface::maxlenof_ori_right_hip_confidence() const 04689 { 04690 return 1; 04691 } 04692 04693 /** Set ori_right_hip_confidence value. 04694 * 04695 Right hip position confidence. 04696 * @param new_ori_right_hip_confidence new ori_right_hip_confidence value 04697 */ 04698 void 04699 HumanSkeletonInterface::set_ori_right_hip_confidence(const float new_ori_right_hip_confidence) 04700 { 04701 data->ori_right_hip_confidence = new_ori_right_hip_confidence; 04702 data_changed = true; 04703 } 04704 04705 /** Get ori_right_knee value. 04706 * 04707 Right knee position vector. 04708 * @return ori_right_knee value 04709 */ 04710 float * 04711 HumanSkeletonInterface::ori_right_knee() const 04712 { 04713 return data->ori_right_knee; 04714 } 04715 04716 /** Get ori_right_knee value at given index. 04717 * 04718 Right knee position vector. 04719 * @param index index of value 04720 * @return ori_right_knee value 04721 * @exception Exception thrown if index is out of bounds 04722 */ 04723 float 04724 HumanSkeletonInterface::ori_right_knee(unsigned int index) const 04725 { 04726 if (index > 9) { 04727 throw Exception("Index value %u out of bounds (0..9)", index); 04728 } 04729 return data->ori_right_knee[index]; 04730 } 04731 04732 /** Get maximum length of ori_right_knee value. 04733 * @return length of ori_right_knee value, can be length of the array or number of 04734 * maximum number of characters for a string 04735 */ 04736 size_t 04737 HumanSkeletonInterface::maxlenof_ori_right_knee() const 04738 { 04739 return 9; 04740 } 04741 04742 /** Set ori_right_knee value. 04743 * 04744 Right knee position vector. 04745 * @param new_ori_right_knee new ori_right_knee value 04746 */ 04747 void 04748 HumanSkeletonInterface::set_ori_right_knee(const float * new_ori_right_knee) 04749 { 04750 memcpy(data->ori_right_knee, new_ori_right_knee, sizeof(float) * 9); 04751 data_changed = true; 04752 } 04753 04754 /** Set ori_right_knee value at given index. 04755 * 04756 Right knee position vector. 04757 * @param new_ori_right_knee new ori_right_knee value 04758 * @param index index for of the value 04759 */ 04760 void 04761 HumanSkeletonInterface::set_ori_right_knee(unsigned int index, const float new_ori_right_knee) 04762 { 04763 if (index > 9) { 04764 throw Exception("Index value %u out of bounds (0..9)", index); 04765 } 04766 data->ori_right_knee[index] = new_ori_right_knee; 04767 data_changed = true; 04768 } 04769 /** Get ori_right_knee_confidence value. 04770 * 04771 Right knee position confidence. 04772 * @return ori_right_knee_confidence value 04773 */ 04774 float 04775 HumanSkeletonInterface::ori_right_knee_confidence() const 04776 { 04777 return data->ori_right_knee_confidence; 04778 } 04779 04780 /** Get maximum length of ori_right_knee_confidence value. 04781 * @return length of ori_right_knee_confidence value, can be length of the array or number of 04782 * maximum number of characters for a string 04783 */ 04784 size_t 04785 HumanSkeletonInterface::maxlenof_ori_right_knee_confidence() const 04786 { 04787 return 1; 04788 } 04789 04790 /** Set ori_right_knee_confidence value. 04791 * 04792 Right knee position confidence. 04793 * @param new_ori_right_knee_confidence new ori_right_knee_confidence value 04794 */ 04795 void 04796 HumanSkeletonInterface::set_ori_right_knee_confidence(const float new_ori_right_knee_confidence) 04797 { 04798 data->ori_right_knee_confidence = new_ori_right_knee_confidence; 04799 data_changed = true; 04800 } 04801 04802 /** Get ori_right_ankle value. 04803 * 04804 Right ankle position vector. 04805 * @return ori_right_ankle value 04806 */ 04807 float * 04808 HumanSkeletonInterface::ori_right_ankle() const 04809 { 04810 return data->ori_right_ankle; 04811 } 04812 04813 /** Get ori_right_ankle value at given index. 04814 * 04815 Right ankle position vector. 04816 * @param index index of value 04817 * @return ori_right_ankle value 04818 * @exception Exception thrown if index is out of bounds 04819 */ 04820 float 04821 HumanSkeletonInterface::ori_right_ankle(unsigned int index) const 04822 { 04823 if (index > 9) { 04824 throw Exception("Index value %u out of bounds (0..9)", index); 04825 } 04826 return data->ori_right_ankle[index]; 04827 } 04828 04829 /** Get maximum length of ori_right_ankle value. 04830 * @return length of ori_right_ankle value, can be length of the array or number of 04831 * maximum number of characters for a string 04832 */ 04833 size_t 04834 HumanSkeletonInterface::maxlenof_ori_right_ankle() const 04835 { 04836 return 9; 04837 } 04838 04839 /** Set ori_right_ankle value. 04840 * 04841 Right ankle position vector. 04842 * @param new_ori_right_ankle new ori_right_ankle value 04843 */ 04844 void 04845 HumanSkeletonInterface::set_ori_right_ankle(const float * new_ori_right_ankle) 04846 { 04847 memcpy(data->ori_right_ankle, new_ori_right_ankle, sizeof(float) * 9); 04848 data_changed = true; 04849 } 04850 04851 /** Set ori_right_ankle value at given index. 04852 * 04853 Right ankle position vector. 04854 * @param new_ori_right_ankle new ori_right_ankle value 04855 * @param index index for of the value 04856 */ 04857 void 04858 HumanSkeletonInterface::set_ori_right_ankle(unsigned int index, const float new_ori_right_ankle) 04859 { 04860 if (index > 9) { 04861 throw Exception("Index value %u out of bounds (0..9)", index); 04862 } 04863 data->ori_right_ankle[index] = new_ori_right_ankle; 04864 data_changed = true; 04865 } 04866 /** Get ori_right_ankle_confidence value. 04867 * 04868 Right ankle position confidence. 04869 * @return ori_right_ankle_confidence value 04870 */ 04871 float 04872 HumanSkeletonInterface::ori_right_ankle_confidence() const 04873 { 04874 return data->ori_right_ankle_confidence; 04875 } 04876 04877 /** Get maximum length of ori_right_ankle_confidence value. 04878 * @return length of ori_right_ankle_confidence value, can be length of the array or number of 04879 * maximum number of characters for a string 04880 */ 04881 size_t 04882 HumanSkeletonInterface::maxlenof_ori_right_ankle_confidence() const 04883 { 04884 return 1; 04885 } 04886 04887 /** Set ori_right_ankle_confidence value. 04888 * 04889 Right ankle position confidence. 04890 * @param new_ori_right_ankle_confidence new ori_right_ankle_confidence value 04891 */ 04892 void 04893 HumanSkeletonInterface::set_ori_right_ankle_confidence(const float new_ori_right_ankle_confidence) 04894 { 04895 data->ori_right_ankle_confidence = new_ori_right_ankle_confidence; 04896 data_changed = true; 04897 } 04898 04899 /** Get ori_right_foot value. 04900 * 04901 Right foot position vector. 04902 * @return ori_right_foot value 04903 */ 04904 float * 04905 HumanSkeletonInterface::ori_right_foot() const 04906 { 04907 return data->ori_right_foot; 04908 } 04909 04910 /** Get ori_right_foot value at given index. 04911 * 04912 Right foot position vector. 04913 * @param index index of value 04914 * @return ori_right_foot value 04915 * @exception Exception thrown if index is out of bounds 04916 */ 04917 float 04918 HumanSkeletonInterface::ori_right_foot(unsigned int index) const 04919 { 04920 if (index > 9) { 04921 throw Exception("Index value %u out of bounds (0..9)", index); 04922 } 04923 return data->ori_right_foot[index]; 04924 } 04925 04926 /** Get maximum length of ori_right_foot value. 04927 * @return length of ori_right_foot value, can be length of the array or number of 04928 * maximum number of characters for a string 04929 */ 04930 size_t 04931 HumanSkeletonInterface::maxlenof_ori_right_foot() const 04932 { 04933 return 9; 04934 } 04935 04936 /** Set ori_right_foot value. 04937 * 04938 Right foot position vector. 04939 * @param new_ori_right_foot new ori_right_foot value 04940 */ 04941 void 04942 HumanSkeletonInterface::set_ori_right_foot(const float * new_ori_right_foot) 04943 { 04944 memcpy(data->ori_right_foot, new_ori_right_foot, sizeof(float) * 9); 04945 data_changed = true; 04946 } 04947 04948 /** Set ori_right_foot value at given index. 04949 * 04950 Right foot position vector. 04951 * @param new_ori_right_foot new ori_right_foot value 04952 * @param index index for of the value 04953 */ 04954 void 04955 HumanSkeletonInterface::set_ori_right_foot(unsigned int index, const float new_ori_right_foot) 04956 { 04957 if (index > 9) { 04958 throw Exception("Index value %u out of bounds (0..9)", index); 04959 } 04960 data->ori_right_foot[index] = new_ori_right_foot; 04961 data_changed = true; 04962 } 04963 /** Get ori_right_foot_confidence value. 04964 * 04965 Right foot position confidence. 04966 * @return ori_right_foot_confidence value 04967 */ 04968 float 04969 HumanSkeletonInterface::ori_right_foot_confidence() const 04970 { 04971 return data->ori_right_foot_confidence; 04972 } 04973 04974 /** Get maximum length of ori_right_foot_confidence value. 04975 * @return length of ori_right_foot_confidence value, can be length of the array or number of 04976 * maximum number of characters for a string 04977 */ 04978 size_t 04979 HumanSkeletonInterface::maxlenof_ori_right_foot_confidence() const 04980 { 04981 return 1; 04982 } 04983 04984 /** Set ori_right_foot_confidence value. 04985 * 04986 Right foot position confidence. 04987 * @param new_ori_right_foot_confidence new ori_right_foot_confidence value 04988 */ 04989 void 04990 HumanSkeletonInterface::set_ori_right_foot_confidence(const float new_ori_right_foot_confidence) 04991 { 04992 data->ori_right_foot_confidence = new_ori_right_foot_confidence; 04993 data_changed = true; 04994 } 04995 04996 /* =========== message create =========== */ 04997 Message * 04998 HumanSkeletonInterface::create_message(const char *type) const 04999 { 05000 throw UnknownTypeException("The given type '%s' does not match any known " 05001 "message type for this interface type.", type); 05002 } 05003 05004 05005 /** Copy values from other interface. 05006 * @param other other interface to copy values from 05007 */ 05008 void 05009 HumanSkeletonInterface::copy_values(const Interface *other) 05010 { 05011 const HumanSkeletonInterface *oi = dynamic_cast<const HumanSkeletonInterface *>(other); 05012 if (oi == NULL) { 05013 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)", 05014 type(), other->type()); 05015 } 05016 memcpy(data, oi->data, sizeof(HumanSkeletonInterface_data_t)); 05017 } 05018 05019 const char * 05020 HumanSkeletonInterface::enum_tostring(const char *enumtype, int val) const 05021 { 05022 if (strcmp(enumtype, "State") == 0) { 05023 return tostring_State((State)val); 05024 } 05025 throw UnknownTypeException("Unknown enum type %s", enumtype); 05026 } 05027 05028 /* =========== messages =========== */ 05029 /** Check if message is valid and can be enqueued. 05030 * @param message Message to check 05031 * @return true if the message is valid, false otherwise. 05032 */ 05033 bool 05034 HumanSkeletonInterface::message_valid(const Message *message) const 05035 { 05036 return false; 05037 } 05038 05039 /// @cond INTERNALS 05040 EXPORT_INTERFACE(HumanSkeletonInterface) 05041 /// @endcond 05042 05043 05044 } // end namespace fawkes