Hi,

I'm working on a project that involves using the Kinect to play a simple 'basket ball' type game. I've implemented a basic method of determining when the player is 'making a shot', based on relative positions and velocities of their hand. Generally it does work well, however it is rather specific requiring the player to make what I've 'determined' to be the 'correct' throwing action.

So I'm wondering what algorithms or methods might exist that could help me build a more robust, yet at the same time more forgiving means of determining when a player is 'throwing' the ball. I know that sounds counter intuitive. I guess when I say robust/forgiving I mean that it can detect a range of 'throw' attempts, not a narrow definition.

Thinking about it I suppose i'm looking for a weighting or scoring system, that evaluates the player motion giving a value to it each frame and when its above a certain value it is considered a throw. In which case i'm no longer looking for an algorithm but have to re-focus on developing a heuristic to score the motion, which is probably beyond the scope of this post.

There isn't much data to work with, although I have the full skeleton of the player, i'm currently just using the hand position (x,y,z) and from that I can determine the current velocity (compared to previous position) and obtain other useful values such as overall magnitude, angle etc.

I've graphed out the motion of the hand perform a sequence of throws in the graphic attached. This clearly shows very obvious structures to the throwing motion, which i'm hoping would be sufficient for constructing an algorithm around. (graph x-axis is time, y-axis is various units)
[attachment=12212:handtrackdata_1200B.png]

Blue line is my current attempt to detect when a throw starts (exceeds a fixed velocity in z axis) and ends (falls below a fixed velocity) The actual values are irrelevant, but 1000 = false (not throwing) 1500 = true (throwing).

The Hand position is then yellow Y axis (height), dark green (at the bottom of graph) Z axis (depth).
The hand velocity is blue for y axis and black for z axis, frequently these match up not only in time, but also in value, suggesting a close to 45 degree angle of throw, though that is non-optimal, should be around 50-65 degrees.
Finally the light green line is the overall magnitude of the velocity in Y and Z axis.

There are issues with my current method, in that since i'm waiting for the z axis velocity of the hand to exceed a specific value, this can mean i'm losing useful data before this point. Indeed it can lead to bogus results when I try to calculate the throwing velocity/force/angle using the data at the start and end points of the throw. This is something i'd like to address, by having an algorithm which can more correctly determine when a throw has started, hence my overall question of this post.

One though I had was to back track from the 'end' point of the throw, when the ball is/should be released from the hand, as this seems to be the simplest point to determine as generally either

a. The difference in y axis between current and last frame should negative. I.e. the players throw has gone through its own apex.
b. The velocity in the z -axis (forward/back from the players body) has dropped to nothing or negative indicating they are no longer moving their hand/arm forward.

Then its a case of looking backwards for some indication of when the throw starts.However again this is very specific and looking at the graph, there are very clear patterns in the throwing motion that I can't help feeling could be utilised with some algorithm to provide a more robust method of detecting the start/end points of a throw. Perhaps something like pattern matching?


So I'd be interested to hear of any suggestions of algorithms or methods to explore.

thanks