Geek asks and answers

Reverse Projection of a 2D Point on a 3D Plucker Line

I am trying to create a tracker (manual traffic of a personal project), and for this reason I need to reverse a 2d point project into a 3d line using the Plucker coordinates. (e.g. ray tracing)

As input, I have 2d coordinates of the point and the projection matrix.

Information on the Internet about plucker coordinates gives an overview of why they are useful, but there is no paper analytically describing the above procedure. (they just mention that they return to the plucker line without any further descriptions)

Can someone please point me in the right direction?

+6
source share
3 answers

-, , /, "" plucker, .

  • 2D- ()

, 2d- (3D-). . ( ..).

.

, 2 . ( )

  • ( )
  • @ ( , → plucker)

( , , , .)

,

  • (p)
  • (d) ( @) ( )

, , , , . , ( , plucker), plucker-line

Plucker - :

  • ( !!! → d → )

  • "" (m) , :

    m = p ^ d (^ → )

, , , , , .

, plucker-line,

+7

Matlab/Octave!

:

% line = point join point
function L=join(A, B)
L=[
        A(1)*B(2)-A(2)*B(1);
        A(1)*B(3)-A(3)*B(1);
        A(1)*B(4)-A(4)*B(1);
        A(2)*B(3)-A(3)*B(2);
        A(2)*B(4)-A(4)*B(2);
        A(3)*B(4)-A(4)*B(3)
];
end % function

6

Lx=B*A'-A*B'


X=pinv(P)*x


x=[u v 1]'

- (u, v)

pinv(P)

.

C=null(P);
C=C/C(4)

, ,

L=join(X,C)

, :

% Get length of principal ray
m3n=norm(P(3,1:3));
% Enforce positivity of determinant
if (det(P(:,1:3))<0)
    m3n=-m3n;
end % if
% Normalize
P=P/m3n;

3x3 ( ), L C X.

: . [x0 x1 x2] ', :

A=[
  - p12*p23 + p13*p22, + p02*p23 - p03*p22, + p03*p12 - p02*p13  
  + p11*p23 - p13*p21, - p01*p23 + p03*p21, + p01*p13 - p03*p11  
  - p11*p22 + p12*p21, + p01*p22 - p02*p21, + p02*p11 - p01*p12  
  - p10*p23 + p13*p20, + p00*p23 - p03*p20, + p03*p10 - p00*p13  
  + p10*p22 - p12*p20, - p00*p22 + p02*p20, + p00*p12 - p02*p10  
  - p10*p21 + p11*p20, + p00*p21 - p01*p20, + p01*p10 - p00*p11  
]

,

d =
     p01*p12*x2 - p02*p11*x2 - p01*p22*x1 + p02*p21*x1 + p11*p22*x0 - p12*p21*x0
     p02*p10*x2 - p00*p12*x2 + p00*p22*x1 - p02*p20*x1 - p10*p22*x0 + p12*p20*x0
     p00*p11*x2 - p01*p10*x2 - p00*p21*x1 + p01*p20*x1 + p10*p21*x0 - p11*p20*x0

:

m =
     p03*p10*x2 - p00*p13*x2 + p00*p23*x1 - p03*p20*x1 - p10*p23*x0 + p13*p20*x0
     p03*p11*x2 - p01*p13*x2 + p01*p23*x1 - p03*p21*x1 - p11*p23*x0 + p13*p21*x0
     p03*p12*x2 - p02*p13*x2 + p02*p23*x1 - p03*p22*x1 - p12*p23*x0 + p13*p22*x0

, [x2 x1 x0] , . MATLAB:

syms p00 p01 p02 p03 p10 p11 p12 p13 p20 p21 p22 p23 real
P=[ p00 p01 p02 p03 
    p10 p11 p12 p13 
    p20 p21 p22 p23 
]

% Some Image Point
syms x0 x1 x2 real 
x=[x0 x1 x2]'

% Source Position
C=null(P)

% Backprojection of x
Xtilde=pinv(P)*x

% Backprojection line (Plücker Matrix)
Lx=simplify(C*Xtilde' - Xtilde*C')

% It homogeneous...
arbitrary_scale=(p00*p11*p22 - p00*p12*p21 - p01*p10*p22 + p01*p12*p20 + p02*p10*p21 - p02*p11*p20)
Lx=Lx*arbitrary_scale

% Plücker Coordinates:
L=[Lx(1,2) Lx(1,3) Lx(1,4) Lx(2,3) Lx(2,4) Lx(3,4)];
% Direction
d=[-L(3) -L(5) -L(6)]';
% Moment
m=[L(4) -L(2) L(1)]';


% In matrix form
A=[
  - p12*p23 + p13*p22, + p02*p23 - p03*p22, + p03*p12 - p02*p13  
  + p11*p23 - p13*p21, - p01*p23 + p03*p21, + p01*p13 - p03*p11  
  - p11*p22 + p12*p21, + p01*p22 - p02*p21, + p02*p11 - p01*p12  
  - p10*p23 + p13*p20, + p00*p23 - p03*p20, + p03*p10 - p00*p13  
  + p10*p22 - p12*p20, - p00*p22 + p02*p20, + p00*p12 - p02*p10  
  - p10*p21 + p11*p20, + p00*p21 - p01*p20, + p01*p10 - p00*p11  
]

% Verification: (should be zero)
simplify(A*x - L')
+2

, , OP, @André Aichert p493 [1].

MATLAB Plucker, A B C.

A = [0 0 0]';
B = [0 0 5]';
C = [1 1 0]';

L = pluckerline(A,B);

distance = compute_plucker_distance(C, L) % Will output 1.4142

%%-------------------------------------------------------------------------

% Comptes the Plucker line passing through points A and B
function L = pluckerline(A, B)
    l = (B - A) / norm(B - A);
    m = cross(A, l);

    L = [l ; m];
end

%%-------------------------------------------------------------------------

% Comptes the distance between the point P and Plucker line L
function distance = compute_plucker_distance(P, L)
    l = L(1:3);
    m = L(4:end);

    distance = norm(cross(P, l) - m);
end

[1] Sommer, Gerald, ed. Geometric computing with Clifford algebras: theoretical foundations and applications in computer vision and robotics. Springer Science and Business Media, 2013.

+1
source

More articles:


All Articles