+106 -17

src/xrt/auxiliary/util/u_hand_tracking.c

··· 27 27 (XRT_SPACE_RELATION_ORIENTATION_VALID_BIT | XRT_SPACE_RELATION_ORIENTATION_TRACKED_BIT | \ 28 28 XRT_SPACE_RELATION_POSITION_VALID_BIT | XRT_SPACE_RELATION_POSITION_VALID_BIT) 29 29 30 30 + #define HAND_MAX_SPLAY_ANGLE 10.0f 31 31 + 30 32 struct u_joint_curl_model 31 33 { 32 34 enum xrt_hand_joint joint_id; ··· 290 292 param->radius *= scale; 291 293 } 292 294 295 295 + 296 296 + static void 297 297 + u_hand_joints_set_default_root_poses(struct u_hand_tracking *set) 298 298 + { 299 299 + const struct xrt_quat identity_quat = XRT_QUAT_IDENTITY; 300 300 + 301 301 + // wrist and palm mostly fixed poses 302 302 + set->joints.wrist.relation.pose = (struct xrt_pose){ 303 303 + .position = hand_joint_default_set_curl_model_defaults[XRT_HAND_JOINT_WRIST].position_offset, 304 304 + .orientation = identity_quat}; 305 305 + set->joints.wrist.relation.linear_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 306 306 + set->joints.wrist.relation.angular_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 307 307 + set->joints.wrist.relation.relation_flags = POSE_VALID_FLAGS | VELOCIY_VALID_FLAGS; 308 308 + 309 309 + set->joints.palm.relation.pose = (struct xrt_pose){ 310 310 + .position = hand_joint_default_set_curl_model_defaults[XRT_HAND_JOINT_PALM].position_offset, 311 311 + .orientation = identity_quat}; 312 312 + set->joints.palm.relation.linear_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 313 313 + set->joints.palm.relation.angular_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 314 314 + set->joints.palm.relation.relation_flags = POSE_VALID_FLAGS | VELOCIY_VALID_FLAGS; 315 315 + } 316 316 + 317 317 + static void 318 318 + u_hand_joints_fill_finger_value_by_curl(const float curl_value, 319 319 + const int joint_count, 320 320 + struct u_hand_tracking_finger_value *out_finger_value) 321 321 + { 322 322 + out_finger_value->splay = 0.0f; 323 323 + out_finger_value->joint_count = joint_count; 324 324 + 325 325 + for (int i = 0; i < joint_count; i++) 326 326 + out_finger_value->joint_curls[i] = curl_value; 327 327 + } 328 328 + 329 329 + static void 330 330 + u_hand_joints_set_hand_values_by_curl(const struct u_hand_tracking_curl_values *curl_values, 331 331 + struct u_hand_tracking_values *out_hand_tracking_values) 332 332 + { 333 333 + u_hand_joints_fill_finger_value_by_curl(curl_values->thumb, 4, &out_hand_tracking_values->thumb); 334 334 + u_hand_joints_fill_finger_value_by_curl(curl_values->index, 5, &out_hand_tracking_values->index); 335 335 + u_hand_joints_fill_finger_value_by_curl(curl_values->middle, 5, &out_hand_tracking_values->middle); 336 336 + u_hand_joints_fill_finger_value_by_curl(curl_values->ring, 5, &out_hand_tracking_values->ring); 337 337 + u_hand_joints_fill_finger_value_by_curl(curl_values->little, 5, &out_hand_tracking_values->little); 338 338 + } 339 339 + 340 340 + 341 341 + static void 342 342 + u_hand_joints_apply_splay(float splay_value, struct u_joint_space_relation *out_bone) 343 343 + { 344 344 + const struct xrt_vec3 y_axis = XRT_VEC3_UNIT_Y; 345 345 + struct xrt_quat splay_quat; 346 346 + quat_from_angle_vector_clockwise(splay_value * DEG_TO_RAD(HAND_MAX_SPLAY_ANGLE), &y_axis, &splay_quat); 347 347 + 348 348 + math_quat_rotate(&splay_quat, &out_bone->relation.pose.orientation, &out_bone->relation.pose.orientation); 349 349 + } 350 350 + 351 351 + static void 352 352 + u_hand_joints_update_finger(const struct u_hand_tracking *set, 353 353 + struct u_finger_joint_set *joint_set, 354 354 + enum xrt_hand hand, 355 355 + uint64_t at_timestamp_ns, 356 356 + const struct u_hand_tracking_finger_value *value) 357 357 + { 358 358 + struct u_joint_space_relation origin = set->joints.wrist; 359 359 + 360 360 + struct u_joint_space_relation *prev = &origin; 361 361 + for (int joint_num = 0; joint_num < joint_set->joint_count; joint_num++) { 362 362 + struct u_joint_space_relation *joint = &joint_set->joints[joint_num]; 363 363 + u_hand_joint_compute_next_by_curl(set, prev, hand, at_timestamp_ns, joint, 364 364 + value->joint_curls[joint_num]); 365 365 + 366 366 + // apply the splay to the proximal bone 367 367 + if (u_hand_joint_is_proximal(joint->joint_id)) 368 368 + u_hand_joints_apply_splay(value->splay, joint); 369 369 + 370 370 + prev = joint; 371 371 + } 372 372 + } 373 373 + 374 374 + void 375 375 + u_hand_joints_update(struct u_hand_tracking *set, 376 376 + enum xrt_hand hand, 377 377 + uint64_t at_timestamp_ns, 378 378 + const struct u_hand_tracking_values *values) 379 379 + { 380 380 + u_hand_joints_set_default_root_poses(set); 381 381 + 382 382 + u_hand_joints_update_finger(set, &set->joints.fingers[XRT_FINGER_LITTLE], hand, at_timestamp_ns, 383 383 + &values->little); 384 384 + u_hand_joints_update_finger(set, &set->joints.fingers[XRT_FINGER_RING], hand, at_timestamp_ns, &values->ring); 385 385 + u_hand_joints_update_finger(set, &set->joints.fingers[XRT_FINGER_MIDDLE], hand, at_timestamp_ns, 386 386 + &values->middle); 387 387 + u_hand_joints_update_finger(set, &set->joints.fingers[XRT_FINGER_INDEX], hand, at_timestamp_ns, &values->index); 388 388 + u_hand_joints_update_finger(set, &set->joints.fingers[XRT_FINGER_THUMB], hand, at_timestamp_ns, &values->thumb); 389 389 + 390 390 + set->model_data.finger_values = *values; 391 391 + set->timestamp_ns = at_timestamp_ns; 392 392 + } 393 393 + 293 394 void 294 395 u_hand_joint_compute_next_by_curl(const struct u_hand_tracking *set, 295 396 const struct u_joint_space_relation *prev, ··· 338 439 .y = defaults.position_offset.y, 339 440 .z = defaults.position_offset.z}; 340 441 } 442 442 + 443 443 + 341 444 math_pose_transform(&pose, &offset_pose, &pose); 342 445 343 446 ··· 405 508 float curl_index = curl_values->index; 406 509 float curl_thumb = curl_values->thumb; 407 510 408 408 - const struct xrt_quat identity_quat = XRT_QUAT_IDENTITY; 409 511 410 512 //! @todo: full relations with velocities 411 513 412 412 - // wrist and palm mostly fixed poses 413 413 - set->joints.wrist.relation.pose = (struct xrt_pose){ 414 414 - .position = hand_joint_default_set_curl_model_defaults[XRT_HAND_JOINT_WRIST].position_offset, 415 415 - .orientation = identity_quat}; 416 416 - set->joints.wrist.relation.linear_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 417 417 - set->joints.wrist.relation.angular_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 418 418 - set->joints.wrist.relation.relation_flags = POSE_VALID_FLAGS | VELOCIY_VALID_FLAGS; 419 419 - 420 420 - set->joints.palm.relation.pose = (struct xrt_pose){ 421 421 - .position = hand_joint_default_set_curl_model_defaults[XRT_HAND_JOINT_PALM].position_offset, 422 422 - .orientation = identity_quat}; 423 423 - set->joints.palm.relation.linear_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 424 424 - set->joints.palm.relation.angular_velocity = (struct xrt_vec3)XRT_VEC3_ZERO; 425 425 - set->joints.palm.relation.relation_flags = POSE_VALID_FLAGS | VELOCIY_VALID_FLAGS; 514 514 + u_hand_joints_set_default_root_poses(set); 426 515 427 516 struct u_joint_space_relation *prev = &set->joints.wrist; 428 517 for (int joint_num = 0; joint_num < set->joints.fingers[XRT_FINGER_LITTLE].joint_count; joint_num++) { ··· 459 548 prev = joint; 460 549 } 461 550 462 462 - set->model_data.curl_values = *curl_values; 551 551 + u_hand_joints_set_hand_values_by_curl(curl_values, &set->model_data.finger_values); 463 552 set->timestamp_ns = at_timestamp_ns; 464 553 } 465 554 ··· 600 689 }, 601 690 }}}}}; 602 691 603 603 - set->model = XRT_HAND_TRACKING_MODEL_FINGERL_CURL; 692 692 + set->model = XRT_HAND_TRACKING_MODEL_INTRINSIC; 604 693 set->scale = scale; 605 694 606 695 struct u_hand_tracking_curl_values values = {0, 0, 0, 0, 0};

+27 -5

src/xrt/auxiliary/util/u_hand_tracking.h

··· 21 21 /*! 22 22 * The hand tracking model being used. 23 23 * 24 24 - * XRT_HAND_TRACKING_MODEL_FINGERL_CURL uses one curl value per finger to 25 25 - * synthesize hand joint positions. 24 24 + * XRT_HAND_TRACKING_MODEL_INTRINSIC for devices that measure hand tracking through sensors, ie gloves and knuckles 25 25 + * XRT_HAND_TRACKING_MODEL_EXTRINSIC for devices that measure hand tracking through external factors like cameras 26 26 * 27 27 * @ingroup aux_util 28 28 */ 29 29 enum u_hand_tracking_model 30 30 { 31 31 - XRT_HAND_TRACKING_MODEL_FINGERL_CURL, 32 32 - XRT_HAND_TRACKING_MODEL_CAMERA, 31 31 + XRT_HAND_TRACKING_MODEL_INTRINSIC, 32 32 + XRT_HAND_TRACKING_MODEL_EXTRINSIC, 33 33 + }; 34 34 + 35 35 + struct u_hand_tracking_finger_value 36 36 + { 37 37 + float splay; 38 38 + 39 39 + float joint_curls[5]; 40 40 + int joint_count; 41 41 + }; 42 42 + 43 43 + struct u_hand_tracking_values 44 44 + { 45 45 + struct u_hand_tracking_finger_value little; 46 46 + struct u_hand_tracking_finger_value ring; 47 47 + struct u_hand_tracking_finger_value middle; 48 48 + struct u_hand_tracking_finger_value index; 49 49 + struct u_hand_tracking_finger_value thumb; 33 50 }; 34 51 35 52 /*! ··· 93 110 94 111 enum u_hand_tracking_model model; 95 112 union { 96 96 - struct u_hand_tracking_curl_values curl_values; 113 113 + struct u_hand_tracking_values finger_values; 97 114 } model_data; 98 115 99 116 struct u_hand_joint_default_set joints; ··· 189 206 uint64_t at_timestamp_ns, 190 207 struct u_hand_tracking_curl_values *curl_values); 191 208 209 209 + void 210 210 + u_hand_joints_update(struct u_hand_tracking *set, 211 211 + enum xrt_hand hand, 212 212 + uint64_t at_timestamp_ns, 213 213 + const struct u_hand_tracking_values *values); 192 214 /*! 193 215 * Simple helper function for positioning hands on Valve Index controllers. 194 216 *

+1 -1

src/xrt/drivers/remote/r_device.c

··· 259 259 } 260 260 261 261 enum xrt_hand hand = rd->is_left ? XRT_HAND_LEFT : XRT_HAND_RIGHT; 262 262 - u_hand_joints_init_default_set(&rd->hand_tracking, hand, XRT_HAND_TRACKING_MODEL_FINGERL_CURL, 1.0); 262 262 + u_hand_joints_init_default_set(&rd->hand_tracking, hand, XRT_HAND_TRACKING_MODEL_INTRINSIC, 1.0); 263 263 264 264 // Setup variable tracker. 265 265 u_var_add_root(rd, rd->base.str, true);

+1 -1

src/xrt/drivers/survive/survive_driver.c

··· 1050 1050 survive->base.get_hand_tracking = survive_controller_get_hand_tracking; 1051 1051 1052 1052 enum xrt_hand hand = idx == SURVIVE_LEFT_CONTROLLER_INDEX ? XRT_HAND_LEFT : XRT_HAND_RIGHT; 1053 1053 - u_hand_joints_init_default_set(&survive->ctrl.hand_tracking, hand, XRT_HAND_TRACKING_MODEL_FINGERL_CURL, 1053 1053 + u_hand_joints_init_default_set(&survive->ctrl.hand_tracking, hand, XRT_HAND_TRACKING_MODEL_INTRINSIC, 1054 1054 1.0); 1055 1055 1056 1056 survive->base.outputs[0].name = XRT_OUTPUT_NAME_INDEX_HAPTIC;

+1 -1

src/xrt/drivers/vive/vive_controller.c

··· 1105 1105 1106 1106 enum xrt_hand hand = d->config.variant == CONTROLLER_INDEX_LEFT ? XRT_HAND_LEFT : XRT_HAND_RIGHT; 1107 1107 1108 1108 - u_hand_joints_init_default_set(&d->hand_tracking, hand, XRT_HAND_TRACKING_MODEL_FINGERL_CURL, 1.0); 1108 1108 + u_hand_joints_init_default_set(&d->hand_tracking, hand, XRT_HAND_TRACKING_MODEL_INTRINSIC, 1.0); 1109 1109 1110 1110 d->base.binding_profiles = vive_binding_profiles_index; 1111 1111 d->base.binding_profile_count = vive_binding_profiles_index_count;