What is the difference between ProjectionTransformMatrix VTK and GL_PROJECTION OpenGL?

I am having serious problems understanding the transformations involved in the WTC. OpenGL has fairly good documentation, and I got the impression that VTK is very similar to OpenGL (it is in many ways). But when it comes to transformations, this seems to be a completely different story.

This is good OpenGL documentation on related transforms: http://www.songho.ca/opengl/gl_transform.html

Perspective projection matrix in OpenGL:

enter image description here

I was wondering if this formula in VTK would apply the VTK projection matrix (by cross-checking with the VTK projection matrix).

Corresponding camera and rendering options:

double crSet[2] = {10, 1000};
double windowSize[2];
proj = renderer->GetActiveCamera()->GetProjectionTransformMatrix(windowSize[0]/windowSize[1], crSet[0], crSet[1]);


The projection transformation matrix obtained for this configuration:

enter image description here

The values ​​(3,3) and (3,4) of the projection matrix (say indexed from 1 to 4 for rows and columns) should be - (f + n) / (fn) and -2 * f * n / (fn) respectively. In my camera settings, VTK is closest to you 10 and farz is 1000 and so I should get -1.020 and -20.20 respectively at (3,3) and (3,4) matrix places. But these are -1010 and -10000.

I changed my clipping range values ​​to see the changes and the position (3,3) is always close to + farz, which doesn't make any sense to me. It would also be great if someone can explain why it is 3.7320 in the (1,1) and (2,2) positions. And this value does NOT change when the render window is resized. Quite perplexing.

I can see in the VTKCamera class reference that GetProjectionTransformMatrix () returns a transformation matrix that maps from camera coordinates to view coordinates.

VTK camera class reference

This is a good description of the transforms involved in OpenGL rendering:

enter image description here

The OpenGL Projection Matrix is ​​a matrix that maps eye coordinates to clip coordinates. Undoubtedly, the coordinates of the eyes in OpenGL are the same as the coordinates of the camera in VTK. But are the coordinates of the clips in OpenGL the same as the coordinates of the VTK reel?

My goal is to simulate a real webcam (already calibrated) in VTK to render a 3D model.


source to share

1 answer

Well, the documentation you link to actually explains it (emphasis mine):



Returns a projection transformation matrix that transforms camera coordinates to view coordinates . This method calculates aspect, nearz and farz, then calls a more specific signature Get Composite ProjectionTransformMatrix




Returns the concatenation of the ViewTransform and ProjectionTransform. This transformation converts world coordinates to view coordinates. Aspect is the width / height for the viewport, and the near and far are the Z-buffer values ​​that are mapped to the near and far clipping planes. The coordinates of the point of view of the point inside the frustum are in the range ([-1, + 1], [- 1, + 1], [nearz, farz] ).

Note that this does not match OpenGL window space and normalized device space. If you find the term "viewport coordinates" for this poor choice, but whatever. What worries me more is that the matrix is ​​not actually converted to this "viewport space" but to some equivalent of a clip. Only after breaking the perspective will the coordinates be within the range specified above for the "view space" definition.

But are the clip coordinates in OpenGL the same as the view VTK coordinates?

So this answer is clear. But it's close. Basically, this projection matrix is ​​just scaled and z-shifted, and it's easy to convert between the two. Basically, you can just take znear

and zfar

from the VTK matrix and put it in the OpenGL matrix matrix formula you linked above, replacing only those two matrix elements.



All Articles