Inverse Kinematics


After a busy few weeks back into the semester aswell as a week long battle with fresher flu, i'm finally feeling better and ready to settle back into the lab.

I left off continuing down the psuedo mirroring pathway and had gotten to the point where I could manipulate one of the model hands based on leap data. (The idea of separating the leap motion "magic" and a visual model). Currently the way I do this is by just manipulating the transform of each of the game object points to match the leap points that I have. However as mentioned previously I currently only have the points for each finger tip, palm position and wrist position so by just using these points and updating the model each update frame it means that only the tips of the finger, palm and wrist move and the rest of the hand stays at its original place which creates a rather "spastic" looking hand. I think this could be on the right track but I need to work out how to move all the points in the hand based on these positions.

After a little bit of research and listening for key words around the HCI lab I think I've gathered that the solution to this would be Inverse Kinematics. This is something that I understand Matt has done with his robot arms, however he's a very busy man currently so I think I will have a little look into it myself and see whether this is a solution or not.

Inverse Kinematics:

This is a way of calculating where each of the joints in a limb are based on an end point. So for example, it's a technique that could be used to calculate where each of the joints in the finger should be based on the goal position of the finger tip. I've looked into a few examples online and a lot of the math seems quite over my head but I made a start anyway using a paper I found here.

Degree's of Freedom:

Okay from my understanding each finger in the hand has four DOF. 
  • 3 DOF for flexion/extension, this is about movements that affect the angle between two parts of the body, flexion bending the finger down and extending the opposite. So by looking at a finger there are three joints that can move up and down equating to 3 DOF.
  • The other degree of freedom comes because one joint can move the finger can move side to side, this comes under abduction/adduction. Abduction, spreading fingers out, adduction, putting them back together again.  

Solutions

The paper outlines a bunch of different solutions and their pro's and cons to each. From what I can tell the optimization based method may be the way to go as it sounds like the most tried and true technique but I'm really not sure and would be something I need to talk to someone else about. Below is a brief summary of the types of solutions outlined in the paper.

  • Algebraic approach, probably not viable as paper talks about how any more than 2 DOF causes issues. 
  • Iterative methods, where the goal is to minimise the difference between the current and goal position of the end effector (the finger tip). There are different ways to do this.
    • Jacobian Inversion method
    • Optimization based (take primary equation as minimization problem, use to minimize error)
    • Cyclic coordinate descent (based on minimization to each joint separately)
    • Jacobian transpose edition 

This is where I'm at with the IK currently but will need to have a chat to one of the lab experts before I can really move on with this side of things. 


Forum Update:

As a random aside, back in early December we posted on the leap motion developers forum for some help regarding the mirroring. Well, late last week my post was bumped by another developer looking to do a similar thing and a member of the Leap motion team replied giving slightly more insight into the original problem:

This post processing thing is not something I understand much about but think it could be quite interesting to look into as an aside, as well as keep an eye on this post for the updates from the development team which could potentially help with the current task on hand. 

Comments

Post a Comment

Popular posts from this blog

Texturing Hands

Image
Texturing the 3D Hands The purpose of texturing the box was so that eventually I could move on to texturing realistic hands.  The first issue I had was that Leap Motion export their prefabs in the ASCII format of .fbx (i'm guessing because it's human readable?) and Blender doesn't allow importing of ASCII file so I had to convert to a Binary file using an external application.  After importing it into Blender I realized there was something called Armature which I hadn't heard of before and as I started reading I figured it would help to look a little bit into how animation works so I could understand the Leap Motion documentation a little bit better. Leap Motion uses something called Skeletal Animation for their hand prefabs. When using this method we split the character object (in this case hands) into two parts, the skin/mesh and the interconnected bones/rig. The bones are connected in a hierarchy so that when you move for example the tip of the fin...
Read more

Day 2

Image
Sam's Demo To start today, as per Holger's request I captured an admittedly very amateur screen cast of Sam's Demo. I wasn't quite sure how to best show the different functions of the program. After a few failures this was the best I could come up with: Will have to add video capturing skills to the list of things that will (hopefully) improve throughout the duration of this student ship. I'm not sure how to get four hands up and going currently. Creating a trial leap hands project Today I decided to start by attempting to create a basic program that could render two hands as an attempt to get my head around the software a little bit.  I first downloaded a bunch of stuff: Leap Orion (The SDK for leap) Leap Core Assets (Package with basic functionality) Leap Graphic Renderer (Aims to create a system that allows you to to treat a collection of objects as a group) I followed a set up tutorial found here: https://developer.leapmotion.com/do...
Read more

5th of Dec Update

Image
Haven't updated in a while because I haven't really made any major achievements, everything has been very gradual in growing my understanding with the Leap API as well as how Sam's demo actually works. I've been focusing the last few days on how Leap works, from how to access any leap data within a script to detecting hands using the HandModels[] from the current Frame. I had a slight play around with the concept of four hands simply by duplicating the LeapController and HandModels twice over and position them in a way as to replicate four hands. Movement is that where both the left hand controls both hands on the left side and vice versa with the right. This was a good way to visualise the task and see the gaps in why this technique wouldn't work. My current challenge is to replicate the mirroring from Sam's demo. Now that I understand the code better I can see that the way that Sam has implemented it is no longer possible with the new Orion API. He mir...
Read more