Resize a circle in openGL keeping the aspect ratio - c++

Question

I wrote this code that prints a circle. The problem comes when I try to resize the window. The aspect ratio is not kept and the circle becomes an oval.
#include<GL/glut.h>
#include<GL/glu.h>
#include<GL/gl.h>
#include<string.h>
#include<stdio.h>
#include <math.h>
#define PI 3.1415
const float DEG2RAD = 3.14159 / 180;
// Keep track of windows changing width and height
GLfloat windowWidth;
GLfloat windowHeight;
void drawCircle(float radius)
{
glBegin(GL_LINE_LOOP);
for (int i = 0; i <= 300; i++) {
double angle = 2 * PI * i / 300;
double x = radius * cos(angle);
double y = radius * sin(angle);
glVertex2d(x, y);
}
glEnd();
}
///////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT );
// Save the matrix state and do the rotations
glMatrixMode(GL_MODELVIEW);
//glPushMatrix();
glColor3d(1, 0, 0);
drawCircle(100);
glutSwapBuffers();
}
///////////////////////////////////////////////////////////
// This function does any needed initialization on the
// rendering context.
void SetupRC()
{
// Light values and coordinates
//glEnable(GL_DEPTH_TEST); // Hidden surface removal
glClearColor(0,0,0,0);
}
void ChangeSize(int w, int h)
{
GLfloat aspectRatio;
GLfloat nRange = 200.0f;
// Prevent a divide by zero
if (h == 0)
h = 1;
// Set Viewport to window dimensions
glViewport(0, 0, w, h);
// Reset coordinate system
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Establish clipping volume (left, right, bottom, top, near, far)
aspectRatio = (GLfloat)w / (GLfloat)h;
if (w <= h)
{
glOrtho(-nRange, nRange, -nRange*aspectRatio, nRange*aspectRatio, -nRange*2, nRange * 2);
}
else
{
glOrtho(-nRange /aspectRatio, nRange /aspectRatio, -nRange, nRange, -nRange * 2, nRange * 2);
}
// Specify the orthographic (or perpendicular) projection,
// i.e., define the viewing box.
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
///////////////////////////////////////////////////////////
// Entry point of the program
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glClear(GL_COLOR_BUFFER_BIT);
glutInitWindowSize(800, 800);
glutCreateWindow("Circle");
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
SetupRC();
glutMainLoop();
return 0;
}
That's the code. I think that the problem is in the ChangeSize() function. Can someone help me? I tried dividing and multiplaying the range by the aspect ratio defined as width/height by the problem remains.

Answer 1

The projection matrix describes the mapping from 3D points of a scene, to 2D points of the viewport. The projection matrix transforms from view space to the clip space.
The coordinates in the clip space are transformed to the normalized device coordinates (NDC) in the range (-1, -1, -1) to (1, 1, 1) by dividing with the w component of the clip coordinates.
At Orthographic Projection the coordinates in the eye space are linearly mapped to normalized device coordinates and the clip sapce coordinates are equal the normalized device coordiantes, because the w component is 1 (for a carthesian coordinate).
Orthographic Projection Matrix:
r = right, l = left, b = bottom, t = top, n = near, f = far
2/(r-l) 0 0 0
0 2/(t-b) 0 0
0 0 -2/(f-n) 0
-(r+l)/(r-l) -(t+b)/(t-b) -(f+n)/(f-n) 1
Lets assume you have a full HD window:
w = 1920.0;
h = 1080.0;
The window has an aspcet ratio of 1.77778
aspectRatio = w / h = 1.77778
If you set up an orthographic projection matrix like this:
glOrtho(-nRange*aspectRatio, nRange*aspectRatio, -nRange, nRange, -nRange*2, nRange*2 );
this will result in the following orthographic projections matrix (1.0 / 1.77778 == 0.5625):
0.5625/nRange 0 0.0 0.0
0.0 1.0/nRange 0.0 0.0
0.0 0.0 0.5/nRange 0.0
0.0 0.0 0.0 1.0
When a geometry is drawn, then each point of the geometry is transformed by the projection matrix. If a circle is drawn in the XY-plane of the viewport,
then the X-coordinate is scaled by 0.5625/nRange:
X' = X * prjMat[0][0] = X * 0.5625/nRange
while the Y-coordinate is scaled by 1.0/nRange
Y' = Y * prjMat[1][1] = Y * 1.0/nRange
This means, the orthographic projection matrix applies the reciprocal aspect ratio of the viewport to the geometry, when the geometry is transformed from view space to normalized device space.
This causes that the perfect circle is distorted to an ellipse, in normalized device space and looks like this:
If you stretch this ellipse back to the rectangular viewport, the you can see the perfect circle in the window or on the screen: