views:

657

answers:

4

Hi everyone. I think this is probably a simple maths question but I have no idea what's going on right now.

I'm capturing the positions of "markers" on a webcam and I have a list of markers and their co-ordinates. Four of the markers are the outer corners of a work surface, and the fifth (green) marker is a widget. Like this:

alt text

Here's some example data:

  • Top left marker (a=98, b=86)
  • Top right marker (c=119, d=416)
  • Bottom left marker (e=583, f=80)
  • Bottom right marker (g=569, h=409)
  • Widget marker (x=452, y=318)

I'd like to somehow transform the webcam's widget position into a co-ordinate to display on the screen, where top left is 0,0 not 98,86 and somehow take into account the warped angles from the webcam capture.

Where would I even begin? Any help appreciated

A: 

Since your input area isn't a rectangle of the same aspect-ratio as the screen, you'll have to apply some sort of transformation to do the mapping.

What I would do is take the proportions of where the inner point is with respect to the outer sides and map that to the same proportions of the screen.

To do this, calculate the amount of the free space above, below, to the left, and to the right of the inner point and use the ratio to find out where in the screen the point should be.

alt text

Once you have the measurements, place the inner point at:

x = left / (left + right)
y = above / (above + below)

This way, no matter how skewed the webcam frame is, you can still map to the full regular rectangle on the screen.

Ben S
This will produce some strange results. For example, all points on the left edge of the polygon will map to the top-left corner of the screen.
Tom Sirgedas
+9  A: 
Jacob
Thanks for the very detailed answer. I've read it about 10 times now and it's starting to make some sense! Googling for code doesn't bring up much, but I have managed to find PVectors in Processing (http://processing.org/reference/PVector.html) - I assume this is what I need? I'll keep on plugging away and see how far I get!
Al
I'm glad you didn't give up - this stuff is quite simple once you understand it. I'll keep posting updates when I think of something but please feel free to ask questions.
Jacob
And yes, PVectors will help with that, but you'll need something to represent matrices as well. Check out this SO post on doing SVD with PHP, http://stackoverflow.com/questions/960060/singular-value-decomposition-svd-in-php
Jacob
All this may seem very complicated compared to other methods, but it's useful since you can transform several points in the polygon once you find `H` with just matrix multiplication, and if you have access to a good linear algebra library, it's just a few operations.Else, I'd recommend you go for other methods like the one with the triangles.
Jacob
@Al this seems like a very nice answer and you seem to be happy with it, so why not mark it as accepted?
Ivan
Thank you very much for this wonderful answer. I have been trying to implement it in my own project and have stumbled upon a few snags, mostly due to my mathematical shortcomings. I was hoping you might shed some light on some of it.1) I have used AlgLib's RMatrixSVD function to obtain H, but in none of the results have I found your test values;2) Is the order of the WP values in the WP matrix not mixed up?
Domus
Did you normalize the H matrix by dividing H by H(3,3)?
Jacob
Before normalizing I verified whether any of the values in the resulting matrices after the SVD operation corresponded to the first H matrix in your answer, and none appeared, including -0.5692, which was supposed to be h33. I used the same values (coordinates) as in the answer. I suppose I'm overlooking something tiny, but it's been haunting me for days now.
Domus
Jacob, could you explain a little more about what your doing to compute matrix A. When feeding A into a general SVD implementation I'm not seeing the same results as Domus has also stated. I have a feeling that it may be due to differences in what type of matrix the SVD implementation is expecting, from the pseudo-code it looks like A will be a 8x9 matrix, is that right? If you could give a brief description of the actual purpose of the operations being done in your pseudo-code to compute A it would help greatly.
jpierson
@Domus: The results of `H` varies between implementation **before** normalization. You should only compare my `H` and yours after dividing by `h33`.
Jacob
@jpierson: I've included the MATLAB code as well as the `A` matrix.
Jacob
Thank you Jacob for your quick response. I plugged your A matrix into this Online Matrix Calculator to calculate the SVD and the output for U is still a 8x9 matrix instead of the 3x3 matrix you originally posted. I feel like I'm missing something elementary, should I be looking for a reduced form of this matrix?http://www.bluebit.gr/matrix-calculator
jpierson
@jpierson: I apologize, looks like I forgot to mention how to get `H` from `V`. I've updated my answer (it's under *Computing H*). But the `V^T` from the SVD on that website is not quite accurate. Also, remember, it's the transpose of `V` on that website, whereas you need to last column of `V` (and not the transpose).
Jacob
@jpierson: If you use the MATLAB code I've included with octave (freely available at http://www.gnu.org/software/octave/) you'll see that the results are correct (since you have a more accurate decomposition).
Jacob
@jpierson: **WAIT!** You don't need octave: if you set the output precision to 15 decimal places, you get an accurate `V` (doh!). So all you have to do to get the right answer is: 1) Copy the `V` 2) Transpose it 3)Take the last vector and reshape it into a 3x3 matrix (row-major) 4) Now you have `H`! 5) Normalize with `H(3,3)`
Jacob
@jpierson: Or equivalently, take the first row of `V`, reshape it into a 3x3 matrix and normalize.
Jacob
@Jacob: Excellent based off of your original description of V^T and the fact that we needed the last column we have been able to get our code mostly working. We are using C# and ALGLIB currently.
jpierson
@jpierson: Great :) !
Jacob
@Jacob: Thank you very much for your answer. It's been a while and I finally managed, but can't remember how! In any case, the result was phenomenal. I was able to draw directly on my screen using a small flashlight. :)
Domus
@Domus: Congrats! You should link a video sometime :)
Jacob
@Domus: I'm guessing you tracked a point (the flash light) but how did you figure out the orientation?
Jacob
@Jacob: I just aimed the light at the screen (closely enough). The webcam was aimed at the screen and I just had to map the illuminated area, thanks to your algorithm, to the real screen coordinates, and then draw a dot at these coordinates. So the cam was aimed at the screen, not the flashlight. My next step, if ever I find the time, is to have it detect my finger. And then on to some serious interaction. The applications are countless, and it annoys me that other work is in the way of proceeding with it.
Domus
A: 

Try the following: split the original rectangle and this figure with 2 diagonals. Their crossing is (k, l). You have 4 distorted triangles (ab-cd-kl, cd-ef-kl, ef-gh-kl, gh-ab-kl) and the point xy is in one of them.

(4 triangles are better than 2, since the distortion doesn't depend on the diagonal chosen)

You need to find in which triangle point XY is. To do that you need only 2 checks:

  1. Check if it's in ab-cd-ef. If true, go on with ab-cd-ef, (in your case it's not, so we proceed with cd-ef-gh).
  2. We don't check cd-ef-gh, but already check a half of it: cd-gh-kl. The point is there. (Otherwise it would have been ef-gh-kl)

Here's an excellent algorythm to check if a point is in a polygon, using only it's points.

Now you need only to map the point to the original triangle cd-gh-kl. The point xy is a linear combination of the 3 points:

x = c * a1 + g * a2 + k * (1 - a1 - a2)
y = d * a1 + h * a2 + l * (1 - a1 - a2)
a1 + a2 <= 1

2 variables (a1, a2) with 2 equations. I guess you can derive the solution formulae on your own.

Then you just make a linear combinations of a1&a2 with the corresponding points' co-ordinates in the original rectangle. In this case with W (width) and H (height) it's

X = width * a1 + width * a2 + width / 2 * (1 - a1 - a2)
Y = 0 * a1 + height * a2 + height / 2 * (1 - a1 - a2)
culebrón
+1  A: 

Due to perspective effects linear or even bilinear transformations may not be accurate enough. Look at correct perspective mapping and more from google on this phrase, may be this is what you need...

maxim1000
Although Jacob's answer is really lovely, articulate, and has a lot of work in put into it, he seems to miss this important point. Linear systems only compute affine or linear transforms and this transform is clearly not linear. No matter how beautiful the code, programs that compute the correct numbers are better. My uptick to you, maxim.
Die in Sente
Chris Johnson