Does anyone know how to calculate pixel count quickly？

fourmi · March 11, 2022, 11:57am

I found a tool class in JME – AreaUtils.class. When calculating the bounding sphere, the following formula is used: radius = (bound.getRadius() * screenWidth) / (distance * 2); pixel = radius * radius * FastMath.PI;. But I don’t know why this formula works. I think we should use the following formula: radius = (bound.getRadius() * cot(fov / 2) /distance; pixel = radius * radius * FastMath.PI;.
Does anyone know what this is about?

pspeed · March 11, 2022, 12:23pm

Any formula that’s calculating the on-screen pixel area of something and isn’t looking at the projection matrix is going to be wrong, I guess.

In my atlas generator stuff, I use m11 to push the camera in/out for to obtain a particular pixel to unit size… I imagine calculating the area from bounds + distance would involve the reverse in some way:

github.com

Simsilica/SimArboreal-Editor/blob/master/src/main/java/com/simsilica/arboreal/AtlasGeneratorState.java#L460


      
          Vector3f max = bb.getMax(null);
           
          float xSize = Math.max(Math.abs(min.x), Math.abs(max.x));
          float ySize = max.y - min.y;
          float zSize = Math.max(Math.abs(min.z), Math.abs(max.z));
           
          float size = ySize * 0.5f;
          size = Math.max(size, xSize);
          size = Math.max(size, zSize);
          
          // In the projection matrix, [1][1] should be:
          //      (2 * Zn) / camHeight
          // where Zn is distance to near plane.
          float m11 = camera.getViewProjectionMatrix().m11;
          
          // We want our position to be such that
          // 'size' is otherwise = cameraHeight when rendered.
          float z = m11 * size;
                  
          // Add the z extents so that we adjust for the near plane
          // of the bounding box... well we will be rotating so

Edit:

But to me, it does provide some insight into why this is supposed to work:

…it’s just calculating that value manually. And it’s calculating the area of a circle.

fourmi · March 12, 2022, 3:00am

I don’t think the radius should be calculated this way, the formula should be :radius = bound.getRadius() * cot(fov / 2) * screenWidth / distance; . And of course that’s the maximum radius, but it establishes an upper bound.

pspeed · March 12, 2022, 3:39am

cot() of anything fov related is going to be vertical but you are using it to multiply width with no consideration for aspect ratio. So I think it can’t be right.

Presuming the distance is the projected distance along the eye vector, the foreshortening will be a constant. size = distance / ‘foreshortening’

…my memory says that ‘foreshortening’ is m11 in the projection matrix.

screenRadius = boundsRadius / proj.m11

Edit: but I admit my projection matrix fu is very rusty and I’d normally just try it until it worked.

Edit2: this may or may not be useful:
https://www.euclideanspace.com/threed/rendering/opengl/index.htm

…not as clear as the articles I read years ago, though.

fourmi · March 12, 2022, 4:03am

I noticed that Ogre seems to do this:
ogre - Estimate pixel count

Jme seems to do this:

It doesn’t look the same?

pspeed · March 12, 2022, 9:42am

There is no doubt that JME’s util method is wrong… it works only for a very specific projection matrix, I guess.

Ogre’s seems a little dodgy as well. I get that they are trying to deal with non-square pixels by using m00 and m11 but the / distanceSquared bit seems odd. Ah, I see… they are combining the x and the y together. So /2 becomes /4 (x 0.25) and /distance becomes /distanceSquared.

rx = (w/2) * m00 / distance;
ry = (h/2) * m11 / distance;
screenArea = rx * ry;

And I now see I forgot to include distance in my previous post.

So:
screenRadius = boundsRadius / proj.m11
Should have been:
screenRadius = boundsRadius / (proj.m11/distance)
Or:
screenRadius = boundsRadius * proj.m11 / distance
screenArea = screenRadius * screenRadius * PI
…which I guess is the square pixel version of what Ogre is doing.

fourmi · March 12, 2022, 4:17pm

Yeah, I think so. I always thought it was the pixel count of the bounding sphere.

RiccardoBlb · March 14, 2022, 9:18am

Please open an issue on jme’s github repo if you’ve determined this code to be wrong