How can I determine the pixels covered by a transformed triangle (without drawing it)?

Question

I have three points that form a triangle in a 3D scene. I want to apply an arbitrary rotation/translation transformation to this polygon and later check in which pixels of an image they would be rendered (if any), taking occlusion into account. I want to do this without having any window, so that no actual drawing is done (I know the camera parameters and the "virtual" rendering image size).

How can I accomplish this? I thought about OpenGL and the glReadPixels function, but I am not sure that I can query for a 3D point to get its rendered 2D pixel.

For reference, I am working on a computer vision application where I have an image taken by a camera and a 3D model of a virtual object. The virtual object is a mesh of a lot of triangles. What I actually want is to project the virtual object on the image and get the positions in the image of the non-occluded triangles, so that I can manipulate the image in those positions. As I said, I don't really need to draw, just the calculations. Now, I am doing it manually and I can get rid of those points that are occluded by other points, but I do not know how to take occlusion into account when instead of single points, they are planar triangles.

Answer 1

I know you don't want to render, but is this a hard requirement? How about rendering to a texture, and then reading the resulting pixels from the texture? no screen rendering will take place, and you will be taking advantage of the hardware to do it for you. Here's a tutorial that seems to explain how render-to-texture works.

If you really don't want to do any rendering at all, you can always multiply your vertices by your projection matrix, divide by w, discard z, and your x and y are the coordinates of each vertex in screen space (their meaning is dependent on the projection matrix you used).

With your three vertices in screen space, all you have to do is rasterize them to know which pixels lie inside the triangle. Here's a tutorial that seems to explain rasterization.

Answer 2

OpenGL provides occlusion queries, described here. They are not exactly simple to use, but I believe they will do what you need.

Basically, you create an occlusion query object, then "activate" it with glBeginQuery during the rendering that you want to analyze. After you are done drawing the geometry of interest, call glEndQuery and glGetQueryObject, passing GL_QUERY_RESULT.

This technique can be used with the texture rendering technique described above.

For an interesting description of some performance issues and ways to get around them, check out this good page.