Keyboard-Controlled Sign Language Hand Model

struct SLPose {
  std::string description;
  std::map<int, Eigen::Vector3d> angles;  // holds bone_id & xzx angles
};

// Initialize all sign language poses
std::map<char, SLPose> init_sl_poses() {
  std::map<char, SLPose> poses;

  // Lambda to create a pose
  auto make_pose = [](const std::string& desc,
                      std::initializer_list<std::pair<int, Eigen::Vector3d>> angle_list) {
    SLPose pose;
    pose.description = desc;
    for (const auto& p : angle_list) {
      pose.angles[p.first] = p.second;
    }
    return pose;
  };

  // 26 letter definitions (A-Z) start here

  return poses;
}

poses['A'] = make_pose("Fist with thumb alongside", {
  {3, Eigen::Vector3d(0, 20, 0)},    // Thumb proximal
  {4, Eigen::Vector3d(0, 10, 0)},    // Thumb distal
  {6, Eigen::Vector3d(0, 70, 0)},    // Index proximal - curled
  {7, Eigen::Vector3d(0, 70, 0)},    // Index middle - curled
  // Remaining bones
});

void apply_sl_pose(Skeleton& skeleton, const SLPose& pose) {
  // Reset all bones to rest pose
  for (auto& bone : skeleton) {
    bone.xzx.setZero();
  }

  // Apply the pose angles
  for (const auto& [bone_id, angles] : pose.angles) {
    if (bone_id >= 0 && bone_id < static_cast<int>(skeleton.size())) {
      skeleton[bone_id].xzx = angles;
    }
  }
}

void interpolate_to_pose(Skeleton& skeleton, const SLPose& target_pose,
                         double t, const std::vector<Eigen::Vector3d>& start_angles) {
  t = std::min(1.0, std::max(0.0, t));  // Clamp t to [0, 1]

  for (size_t i = 0; i < skeleton.size(); i++) {
    Eigen::Vector3d target_ang = Eigen::Vector3d::Zero();

    auto it = target_pose.angles.find(static_cast<int>(i));
    if (it != target_pose.angles.end()) {
      target_ang = it->second;
    }

    // Linear interpolation
    skeleton[i].xzx = (1.0 - t) * start_angles[i] + t * target_ang;
  }
}

t = t * t * (3.0 - 2.0 * t);
interpolate_to_pose(skeleton, target_pose, t, start_angles);

// Mode: 0 = IK, 1 = FK animation, 2 = sign language pose mode
int mode = 2;  // Default to sign language mode

v.callback_pre_draw = [&](igl::opengl::glfw::Viewer &)->bool
{
  if(mode == 0)  // IK mode
  {
    ik();
  }
  else if(mode == 1)  // FK animation mode
  {
    // Original FK animation code
  }
  else if(mode == 2)  // sign language pose mode
  {
    if(transitioning_to_pose && v.core().is_animating)
    {
      // Smooth transition handling
    }
  }
  update();
  return false;
};

v.callback_key_pressed = [&](
  igl::opengl::glfw::Viewer & viewer,
  unsigned char key,
  int
  )->bool
{
  // Check if it's a letter key
  char upper_key = std::toupper(key);
  if(upper_key >= 'A' && upper_key <= 'Z' && mode == 2)
  {
    auto it = sl_poses.find(upper_key);
    if(it != sl_poses.end())
    {
      // Start transition to new pose - save current angles
      start_angles.clear();
      for(size_t i = 0; i < skeleton.size(); i++) {
        start_angles.push_back(skeleton[i].xzx);
      }
      target_pose = it->second;
      transition_start_time = igl::get_seconds();
      transitioning_to_pose = true;
      current_letter = upper_key;

      std::cout << "sign language Letter: " << upper_key;
      if(!target_pose.description.empty())
      {
        std::cout << " - " << target_pose.description;
      }
      std::cout << std::endl;
      return true;
    }
  }
  // Mode switching code starts here
};

// sign language pose transition variables
bool transitioning_to_pose = false;
double transition_start_time = 0;
double transition_duration = 0.5;  // seconds
SLPose target_pose;
std::vector<Eigen::Vector3d> start_angles;  // Store angles instead of Skeleton
char current_letter = ' ';

std::cout << std::endl;
std::cout << "=== Keyboard-controlled sign language hand model ===" << std::endl;
std::cout << std::endl;
std::cout << "Controls:" << std::endl;
std::cout << "  A-Z      Show sign language letter pose (in sign language mode)" << std::endl;
std::cout << "  0        Reset to rest pose" << std::endl;
std::cout << "  1        Switch to IK mode (drag fingertips)" << std::endl;
std::cout << "  2        Switch to FK animation mode - content from assignment#7" << std::endl;
std::cout << "  3        Switch to sign language alphabet mode (need to set to this mode before using letters)" << std::endl;
std::cout << std::endl;
std::cout << "Current mode (default): sign language Alphabet" << std::endl;
std::cout << "Press any letter A-Z to see the sign language sign!" << std::endl;
std::cout << std::endl;