gl_image_panel.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <cassert>

#include <qgl.h>

#include "gl_image_panel.h"

using namespace jwsc;

GLImagePanel::GLImagePanel(QWidget* parent, const char* name)
    : QGLWidget(parent, name)
{
    img_blk = NULL;
    current_x_index = 0;
    current_y_index = 0;
    current_z_index = 0;

    setMouseTracking(TRUE);

    draw_line = true;
}

void GLImagePanel::set_current_x_index(int index)
{
    current_x_index = index;
    updateGL();
}

void GLImagePanel::set_current_y_index(int index)
{
    current_y_index = index;
    updateGL();
}

void GLImagePanel::set_current_z_index(int index)
{
    current_z_index = index;
    updateGL();
}

void GLImagePanel::set_draw_line(bool b)
{
    draw_line = b;
    updateGL();
}

void GLImagePanel::set_imgblock(Imgblock_f* img_blk)
{
    this->img_blk = img_blk;
    resizeGL(0, 0);
}

void GLImagePanel::initializeGL()
{
    qglClearColor(black);
}

GLImagePanelXY::GLImagePanelXY(QWidget* parent, const char* name)
    : GLImagePanel(parent, name)
{
    xy_img = NULL;

    default_width = 256;
    default_height = 256;
}

void GLImagePanelXY::set_current_z_index(int index)
{
    update_xy_img = 1;

    GLImagePanel::set_current_z_index(index);
}

void GLImagePanelXY::set_draw_x_line(bool b)
{
    draw_x_line = b;
}

void GLImagePanelXY::set_draw_y_line(bool b)
{
    draw_y_line = b;
}

void GLImagePanelXY::set_imgblock(Imgblock_f* img_blk)
{
    update_xy_img = 1;

    if (img_blk == NULL)
    {
        free(xy_img);
        xy_img = NULL;
    }
    else
    {
        int num_rows = img_blk->num_rows;
        int num_cols = img_blk->num_cols;
        xy_img = (float*)realloc(xy_img, 3*num_rows*num_cols*sizeof(float));
    }

    GLImagePanel::set_imgblock(img_blk);
}

void GLImagePanelXY::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);

    if (img_blk == NULL) return;

    int num_rows = img_blk->num_rows;
    int num_cols = img_blk->num_cols;

    if (update_xy_img)
    {
        update_xy_img = 0;

        int img = current_z_index;
        int xy_img_px;

        for (int row = 0; row < num_rows; row++)
        {
            xy_img_px = (num_cols*3)*(num_rows-row-1);

            for (int col = 0; col < num_cols; col++)
            {
                xy_img[ xy_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].r;
                xy_img[ xy_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].g;
                xy_img[ xy_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].b;
            }
        }
    }

    glRasterPos2i(0, 0);
    glDrawPixels((GLsizei)num_cols, (GLsizei)num_rows, GL_RGB, GL_FLOAT,xy_img);

    glColor3f(1.0f, 0, 0);
    if (draw_line)
    {
        if (draw_x_line)
        {
            glBegin(GL_LINES);
            glVertex2i(0, num_rows-current_y_index-1);
            glVertex2i(num_cols, num_rows-current_y_index-1);
            glEnd();
        }
        if (draw_y_line)
        {
            glBegin(GL_LINES);
            glVertex2i(current_x_index, 0);
            glVertex2i(current_x_index, num_rows);
            glEnd();
        }
    }

    glFlush();

    assert(glGetError()==GL_NO_ERROR);
}

void GLImagePanelXY::resizeGL(int w, int h)
{
    int width = default_width;
    int height = default_height;

    if (img_blk != NULL)
    {
        width = img_blk->num_cols;
        height = img_blk->num_rows;

    }

    setFixedSize(width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
}

void GLImagePanelXY::mouseMoveEvent(QMouseEvent* event)
{
    uint32_t x = event->x();
    uint32_t y = event->y();
    uint32_t z = current_z_index;

    if (x >= 0 && y >= 0)
    {
        if (img_blk != NULL && x < img_blk->num_cols && y < img_blk->num_rows)
        {
            emit mouse_position_changed(x, y, z, &(img_blk->pxls[ z ][ y ][ x ]));
        }
    }
}

GLImagePanelXZ::GLImagePanelXZ(QWidget* parent, const char* name)
    : GLImagePanel(parent, name)
{
    xz_img = NULL;

    default_width = 256;
    default_height = 32;
}

void GLImagePanelXZ::set_current_y_index(int index)
{
    update_xz_img = 1;

    GLImagePanel::set_current_y_index(index);
}

void GLImagePanelXZ::set_imgblock(Imgblock_f* img_blk)
{
    update_xz_img = 1;

    if (img_blk == NULL)
    {
        free(xz_img);
        xz_img = NULL;
    }
    else
    {
        int num_cols = img_blk->num_cols;
        int num_imgs = img_blk->num_imgs;
        xz_img = (float*)realloc(xz_img, 3*num_cols*num_imgs*sizeof(float));
    }

    GLImagePanel::set_imgblock(img_blk);
}

void GLImagePanelXZ::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);

    if (img_blk == NULL) return;

    int num_imgs = img_blk->num_imgs;
    int num_cols = img_blk->num_cols;

    if (update_xz_img)
    {
        update_xz_img = 0;

        int row = current_y_index;
        int xz_img_px;

        for (int img = 0; img < num_imgs; img++)
        {
            xz_img_px = (num_cols*3)*(num_imgs-img-1);

            for (int col = 0; col < num_cols; col++)
            {
                xz_img[ xz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].r;
                xz_img[ xz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].g;
                xz_img[ xz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].b;
            }
        }
    }

    glRasterPos2i(0, 0);
    glDrawPixels((GLsizei)num_cols, (GLsizei)num_imgs, GL_RGB, GL_FLOAT,xz_img);

    glColor3f(1.0f, 0, 0);
    if (draw_line)
    {
        glBegin(GL_LINES);
        glVertex2i(0, num_imgs-current_z_index-1);
        glVertex2i(num_cols, num_imgs-current_z_index-1);
        glEnd();
    }

    glFlush();
}

void GLImagePanelXZ::resizeGL(int w, int h)
{
    int width = default_width;
    int height = default_height;

    if (img_blk != NULL)
    {
        width = img_blk->num_cols;
        height = img_blk->num_imgs;
    }

    setFixedSize(width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
}

void GLImagePanelXZ::mouseMoveEvent(QMouseEvent* event)
{
    uint32_t x = event->x();
    uint32_t y = current_y_index;
    uint32_t z = event->y();
    
    if (x >= 0 && z >= 0)
    {
        if (img_blk != NULL && x < img_blk->num_cols && z < img_blk->num_imgs)
        {
            emit mouse_position_changed(x, y, z, &(img_blk->pxls[ z ][ y ][ x ]));
        }
    }
}

GLImagePanelYZ::GLImagePanelYZ(QWidget* parent, const char* name)
    : GLImagePanel(parent, name)
{
    yz_img = NULL;

    default_width = 32;
    default_height = 256;
}

void GLImagePanelYZ::set_current_x_index(int index)
{
    update_yz_img = 1;

    GLImagePanel::set_current_x_index(index);
}

void GLImagePanelYZ::set_imgblock(Imgblock_f* img_blk)
{
    update_yz_img = 1;

    if (img_blk == NULL)
    {
        free(yz_img);
        yz_img = NULL;
    }
    else
    {
        int num_rows = img_blk->num_rows;
        int num_imgs = img_blk->num_imgs;
        yz_img = (float*)realloc(yz_img, 3*num_rows*num_imgs*sizeof(float));
    }

    GLImagePanel::set_imgblock(img_blk);
}

void GLImagePanelYZ::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);

    if (img_blk == NULL) return;

    int num_imgs = img_blk->num_imgs;
    int num_rows = img_blk->num_rows;

    if (update_yz_img)
    {
        update_yz_img = 0;

        int col = current_x_index;
        int yz_img_px;

        for (int row = 0; row < num_rows; row++)
        {
            yz_img_px = (num_imgs*3)*(num_rows-row-1);

            for (int img = 0; img < num_imgs; img++)
            {
                yz_img[ yz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].r;
                yz_img[ yz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].g;
                yz_img[ yz_img_px++ ] = img_blk->pxls[ img ][ row ][ col ].b;
            }
        }
    }

    glRasterPos2i(0, 0);
    glDrawPixels((GLsizei)num_imgs, (GLsizei)num_rows, GL_RGB, GL_FLOAT,yz_img);

    glColor3f(1.0f, 0, 0);
    if (draw_line)
    {
        glBegin(GL_LINES);
        glVertex2i(current_z_index, 0);
        glVertex2i(current_z_index, num_rows);
        glEnd();
    }

    glFlush();
}

void GLImagePanelYZ::resizeGL(int w, int h)
{
    int width = default_width;
    int height = default_height;

    if (img_blk != NULL)
    {
        width = img_blk->num_imgs;
        height = img_blk->num_rows;
    }

    setFixedSize(width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);
}

void GLImagePanelYZ::mouseMoveEvent(QMouseEvent* event)
{
    uint32_t x = current_x_index;
    uint32_t y = event->y();
    uint32_t z = event->x();

    if (y >= 0 && z >= 0)
    {
        if (img_blk != NULL && y < img_blk->num_rows && z < img_blk->num_imgs)
        {
            emit mouse_position_changed(x, y, z, &(img_blk->pxls[ z ][ y ][ x ]));
        }
    }
}