Image scaling (KeepAspectRatioByExpanding) through OpenGL

Simply do the same math you did with KeepAspectRatio, but this time keep the height instead of the width. You'll get a width bigger than 1, so you'll have to use the inverse of it for your texture coordinate.

Normalized coordinates yes/no won't matter, you just have to add these factors for the texture coordinates. For this to work I assume the image fills the whole texture (from (0,0) to (1,1); this makes it easy to multiply the values with your width/height). Texture wrapping has to be off.

Default texture coordinates:

(0,0)-(1,0)|     |(0,1)-(1,1)

Aspect ratios:

tex_ar = tex_width / tex_height; // aspect ratio for the texture being usedscr_ar = scr_width / scr_height; // aspect ratio for the quad being drawn

KeepAspectRatio (touch from the inside):

(0, 0)-----------------------(max(1, scr_ar / tex_ar), 0)|                            |(0, max(1, tex_ar / scr_ar))-(max(1, scr_ / tex_ar), max(1, tex_ar / scr_ar))

KeepAspectRatioByExpanding (touch from outside; just replace max() with min()):

(0, 0)-----------------------(min(1, scr_ar / tex_ar), 0)|                            |(0, min(1, tex_ar / scr_ar))-(min(1, scr_ / tex_ar), min(1, tex_ar / scr_ar))

For your case you'd just have to multiply the resulting texture coordinates with your width/height.

You can simply copy "keep aspect ratio" branch (provided that it is working), and just flip the ratio comparison sign, i.e.:

if (ratiox > ratioy)

becomes

if (ratiox <= ratioy)

But i'm not sure it is actually working (ratio calculations had always bugged me - and yours is tricky), and don't have Qt atm so I can't try. But that should do it. Note that the image will be centered (not left-aligned as on your image), but that can be fixed pretty easily.

EDIT:

Here is source code that works in GLUT application (no QT, sorry):

static void DrawObject(void){     int img_width = 1280;//_frame->width();    int img_height = 720;//_frame->height();    GLfloat offset_x = -1;    GLfloat offset_y = -1;    int p_viewport[4];    glGetIntegerv(GL_VIEWPORT, p_viewport); // don't have QT :'(    GLfloat gl_width = p_viewport[2];//width(); // GL context size    GLfloat gl_height = p_viewport[3];//height();    int n_mode = 0;    switch(n_mode) {    case 0: // KeepAspectRatioByExpanding        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            if(ratioImg < ratioScreen) {                gl_width = 2;                gl_height = 2 * ratioScreen / ratioImg;            } else {                gl_height = 2;                gl_width = 2 / ratioScreen * ratioImg;            }            // calculate image size        }        break;    case 1: // IgnoreAspectRatio        gl_width = 2;        gl_height = 2;        // OpenGL normalized coordinates are -1 to +1 .. hence width (or height) = +1 - (-1) = 2        break;    case 2: // KeepAspectRatio        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            if(ratioImg > ratioScreen) {                gl_width = 2;                gl_height = 2 * ratioScreen / ratioImg;            } else {                gl_height = 2;                gl_width = 2 / ratioScreen * ratioImg;            }            // calculate image size            offset_x = -1 + (2 - gl_width) * .5f;            offset_y = -1 + (2 - gl_height) * .5f;            // center on screen        }        break;    }    glMatrixMode(GL_PROJECTION);    glLoadIdentity();    glMatrixMode( GL_MODELVIEW );    glLoadIdentity();    // just simple ortho view, no fancy transform ...    glBegin(GL_QUADS);        glTexCoord2f(0, 0);        glVertex2f(offset_x, offset_y);        glTexCoord2f(ImgWidth, 0);        glVertex2f(offset_x + gl_width, offset_y);        glTexCoord2f(ImgWidth, ImgHeight);        glVertex2f(offset_x + gl_width, offset_y + gl_height);        glTexCoord2f(0, ImgHeight);        glVertex2f(offset_x, offset_y + gl_height);    glEnd();    // draw a single quad}

This works by comparing screen aspect ratio to image aspect ratio. You are actually comparing ratios of image width to screen width with image height to screen height. That is suspicious at least, not to say wrong.

Also, normalized OpenGL coordinates (provided a simple orthogonal view) are in range (-1, -1) for lower-left corner to (1, 1) for upper right. That means normalized width and height are both 2, and offset is (-1, -1). The rest of the code should be self-explanatory. In case texture is flipped (I tested with kind of generic texture, not sure if it was upright), just change texture coordinates in the respective direction (swap 0s for ImgWidth (or height) and vice versa).

EDIT2:

Using pixel coordinates (not using normalized OpenGL coordinates) is even simpler. You can use:

static void DrawObject(void){     int img_width = 1280;//_frame->width();    int img_height = 720;//_frame->height();    GLfloat offset_x = 0;    GLfloat offset_y = 0;    int p_viewport[4];    glGetIntegerv(GL_VIEWPORT, p_viewport);    GLfloat gl_width = p_viewport[2];//width(); // GL context size    GLfloat gl_height = p_viewport[3];//height();    int n_mode = 0;    switch(n_mode) {    case 0: // KeepAspectRatioByExpanding        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            if(ratioImg < ratioScreen)                gl_height = gl_width / ratioImg;            else                gl_width = gl_height * ratioImg;            // calculate image size        }        break;    case 1: // IgnoreAspectRatio        break;    case 2: // KeepAspectRatio        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            GLfloat orig_width = gl_width;            GLfloat orig_height = gl_height;            // remember those to be able to center the quad on screen            if(ratioImg > ratioScreen)                gl_height = gl_width / ratioImg;            else                gl_width = gl_height * ratioImg;            // calculate image size            offset_x = 0 + (orig_width - gl_width) * .5f;            offset_y = 0 + (orig_height - gl_height) * .5f;            // center on screen        }        break;    }    glMatrixMode(GL_PROJECTION);    glLoadIdentity();    glMatrixMode(GL_MODELVIEW);    glLoadIdentity();    glTranslatef(-1, -1, 0);    glScalef(2.0f / p_viewport[2], 2.0f / p_viewport[3], 1.0);    // just simple ortho view for vertex coordinate to pixel matching    glBegin(GL_QUADS);        glTexCoord2f(0, 0);        glVertex2f(offset_x, offset_y);        glTexCoord2f(img_width, 0);        glVertex2f(offset_x + gl_width, offset_y);        glTexCoord2f(img_width, img_height);        glVertex2f(offset_x + gl_width, offset_y + gl_height);        glTexCoord2f(0, img_height);        glVertex2f(offset_x, offset_y + gl_height);    glEnd();    // draw a single quad}

Note that both versions of the code do use NPOT textures. To adapt the code to fit into your object, one would do something like this:

void GLWidget::paintEvent(QPaintEvent *event){    QPainter painter(this);    painter.setRenderHint(QPainter::Antialiasing);    qDebug() << "> GLWidget::paintEvent OpenGL:"  << ((painter.paintEngine()->type() != QPaintEngine::OpenGL &&                                       painter.paintEngine()->type() != QPaintEngine::OpenGL2) ? "disabled" : "enabled");       QGLContext* context = const_cast<QGLContext *>(QGLContext::currentContext());    if (!context)    {        qDebug() << "> GLWidget::paintEvent !!! Unable to retrieve OGL context";        return;    }    context->makeCurrent();    painter.fillRect(QRectF(QPoint(0, 0), QSize(1280, 768)), Qt::black);    painter.beginNativePainting();    /* Initialize GL extensions */    GLenum err = glewInit();    if (err != GLEW_OK)    {        qDebug() << "> GLWidget::paintEvent !!! glewInit failed with: " << err;        return;    }    if (!GLEW_VERSION_2_1)  // check that the machine supports the 2.1 API.    {        qDebug() << "> GLWidget::paintEvent !!! System doesn't support GLEW_VERSION_2_1";        return;    }    /* Setting up texture and transfering data to the GPU */    static GLuint texture = 0;    if (texture != 0)    {        context->deleteTexture(texture);    }    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0,            GL_LUMINANCE, _frame->width(), _frame->height() + _frame->height() / 2, 0,            GL_LUMINANCE, GL_UNSIGNED_BYTE, _frame->bits());    assert(glGetError() == GL_NO_ERROR);    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);    glEnable(GL_TEXTURE_RECTANGLE_ARB);    glClearColor(0.3, 0.3, 0.4, 1.0);    /* Initialize shaders and execute them */       _init_shaders();    int img_width = _frame->width();    int img_height = _frame->height();    GLfloat offset_x = 0;    GLfloat offset_y = 0;    GLfloat gl_width = width(); // GL context size    GLfloat gl_height = height();    qDebug() << "paint(): gl_width:" << gl_width << " gl_height:" << gl_height <<          " img:" << _frame->width() << "x" << _frame->height();    int fill_mode = 0;    switch(fill_mode) {    case 0: // KeepAspectRatioByExpanding        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            if(ratioImg < ratioScreen)                gl_height = gl_width / ratioImg;            else                gl_width = gl_height * ratioImg;            // calculate image size        }        break;    case 1: // IgnoreAspectRatio        break;    case 2: // KeepAspectRatio        {            float ratioImg = float(img_width) / img_height;            float ratioScreen = gl_width / gl_height;            GLfloat orig_width = gl_width;            GLfloat orig_height = gl_height;            // remember those to be able to center the quad on screen            if(ratioImg > ratioScreen)                gl_height = gl_width / ratioImg;            else                gl_width = gl_height * ratioImg;            // calculate image size            offset_x = 0 + (orig_width - gl_width) * .5f;            offset_y = 0 + (orig_height - gl_height) * .5f;            // center on screen        }        break;    }    glDisable(GL_CULL_FACE); // might cause problems if enabled    glBegin(GL_QUADS);        glTexCoord2f(0, 0);        glVertex2f(offset_x, offset_y);        glTexCoord2f(img_width, 0);        glVertex2f(offset_x + gl_width, offset_y);        glTexCoord2f(img_width, img_height);        glVertex2f(offset_x + gl_width, offset_y + gl_height);        glTexCoord2f(0, img_height);        glVertex2f(offset_x, offset_y + gl_height);    glEnd();    // draw a single quad    painter.endNativePainting();}

Can't guarantee this last code snippet is error-free since I don't have QT. But in case there are any typos, it should be rather straightforward to fix them.