Fawkes API  Fawkes Development Version
HumanSkeletonInterface.cpp
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