OpenGL Gouraud shading

thanks for the quick response!  Here's more details on what I"m doing:

I'm actually displaying the surface normals of my object as RGB colors.  All normals have been normalized, ie. unit length, and I transform each normal to an RGB color as follows:  c = (n + 1)/2

where n is a unit length 3-vector normal, 1 is a vector of 1's, and 2 is simply a scalar. This essentially makes the components of c lie between 0 and 1 (since the components of n lie between -1 and 1).

When I render the object, the colors I see represent the normals.  This is likely to be interpolated, since it will be rare that each pixel will exactly correspond to a vertex in my triangular mesh.  It is more likely the case that a pixel will come from the inside of a triangle, and thus the color will be interpolated from the colors at the vertices.

My formula above is linear, so that interpolating c would interpolate n by the same amount.  This is easy to prove.  But when I read back the pixel values (using glReadPixels) and transform them into normals using
n = 2*c - 1,  I get normals whose lengths are > 1, even though I began with unit-length normals.

There are many such cases: > 700 out of a 50x50 image.  Some have lengths as much as 1.15.  I doubt floating point roundoff errors alone can account for this.

I didn't understand your problem. You want to draw a mesh with goraud shading, right? So, it works, but it works wrong? It doesn't work at all? It work, when you draw it with a glVerte, and it don'twork when you draw it with glDrawElements? Why do you need all these formulas?

kamarey,

I'm not sure how else to explain the problem to you, except to ask you to re-read my original question.

My comment to CJ was just to elaborate on what I was doing, in the hope that by giving more details, whoever is helping to answer my question has more information to work on.  If it confuses you, you can ignore it.  My original question remains unchanged:  do the weights w1, w2, w3 add up to 1 ?

Thanks.

By a more direct experiment, I was able to determine that  OpenGL does interpolate with weights that sum to 1.

So my problem lies elsewhere.... I'm still trying to figure out.

But I performed another simple experiment, as follows:

I rendered a square using glColor3f and glVertex.  The vertices of the square are: (0,0), (100,0), (100,100), (0,100), and they all have the same color, which I randomly picked using a random number generator (it appeared pink).  Call this RGB color K.

Shading model was set to GL_FLAT, there was no lighting or texture mapping.

Then I read back the pixels using glReadPixels, into a buffer of floats.

When I compare the color of the pixels read back with K, they differ by about 0.001 in each RGB component.

When I ran the experiment using different K, I still get a difference of about 0.001.  Sometimes the difference was slightly more, sometimes slightly less.  The difference is present in each of the RGB component.

I'm puzzled by this.  Shouldn't I get back the same color EXACTLY?   Thanks!

Hi.
First of all I must say that I don't have a direct experience with OpenGL, but with implementing various shading algs, therefore goes my remark:
for Gouraud linear interpolation you don't necessarily have to use float computations. It is very popular (and highly likely that OpenGL does it also, imho) to implement it using integer interpolation. If that is true for OpenGL, then your rounding losses are not float rounding losses but pixel-distance-dependant.
The idea of interpolation is just like coordinate interpolation in Bresenhams line alg.

I don't know if this gives you any hint, if not - feel free to ignore my comment :-)

Best wishes,
    Ntr:)

No comment has been added lately, so it's time to clean up this TA.
I will leave a recommendation in the Cleanup topic area that this question is:
 - PAQ'd and pts refunded
Please leave any comments here within the
next seven days.

PLEASE DO NOT ACCEPT THIS COMMENT AS AN ANSWER !

Nic;o)