point3dwidget.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Author:  Jaime Valls Miro <jaime.vallsmiro@eng.uts.edu.au>
**          Hue Tuan Thi <huetuan.thi@uts.edu.au>, (C) 2006
**
** This file is part of the S3D Viewer Project
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include <QtGui>
#include <QtOpenGL>
#include <math.h>

#include "point3dwidget.h"

Point3dWidget::Point3dWidget(QWidget *parent)
    : QGLWidget(parent)
{
    // initiate flags and vars
    xRot = INIT_X;
    yRot = INIT_Y;
    zRot = INIT_Z;
    drawAble = false;
    mousePoint = -1;
    depth = -1.0f;

    // initiate average values
    avgX = 0.0f;
    avgY = 0.0f;
    avgZ = 0.0f;

    // initiate colors
    bColor = QColor(BR*255, BG*255, BB*255);
    pointColor = QColor(0, 0, 255);
    initColor = true;

    // initiate flags
    movingMouse = false;
    bounding = true;
    cameraEnable = true;
    movingClear = false;
    pointDrawn = true;
    cubeDrawn = false;
    cubeWidth = 3;

    // set main window parent
    mainWindow = qobject_cast<QMainWindow *>(parentWidget());

    // set strong focus for mouse and keyboard
    setFocusPolicy(Qt::StrongFocus);
}

Point3dWidget::~Point3dWidget()
{
    makeCurrent();
}

void Point3dWidget::setXRotation(int angle)
{
    normalizeAngle(&angle);
    if (angle != xRot) {
        xRot = angle;
        emit xRotationChanged(angle);
        updateGL();
    }
}

void Point3dWidget::setYRotation(int angle)
{
    normalizeAngle(&angle);
    if (angle != yRot) {
        yRot = angle;
        emit yRotationChanged(angle);
        updateGL();
    }
}

void Point3dWidget::setZRotation(int angle)
{
    normalizeAngle(&angle);
    if (angle != zRot) {
        zRot = angle;
        emit zRotationChanged(angle);
        updateGL();
    }
}

void Point3dWidget::updateFile( FileReader *fd){
    fileReader = fd;
    setDrawAble(true);
    minX = findMin(0);
    maxX = findMax(0);
    minY = -findMin(1);
    maxY = -findMax(1);
    minZ = -findMin(2);
    maxZ = -findMax(2);

    avgX = (minX + maxX)/2;
    avgY = (minY + maxY)/2;
    avgZ = (minZ + maxZ)/2;

    updateGL();
}

float Point3dWidget::findMin(int k){
    float min = 999.0f;

    for( int i = 0; i < fileReader->getNp(); i ++){
        if( fileReader->pointArray[i][k] < min )
            min = fileReader->pointArray[i][k];
    }

    return min;
}

float Point3dWidget::findMax(int k){
    float max = -999.0f; // large enough value

    for( int i = 0; i < fileReader->getNp(); i ++){
        if( fileReader->pointArray[i][k] > max )
            max = fileReader->pointArray[i][k];
    }

    return max;
}

void Point3dWidget::setDrawAble(bool status){
    drawAble = status;
}

void Point3dWidget::initializeGL()
{
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(bColor.red()/255, bColor.green()/255, bColor.blue()/255, 0.0);
}

void Point3dWidget::paintGL()
{
    makeCurrent();
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor((float)bColor.red()/255, (float)bColor.green()/255, (float)bColor.blue()/255, 0.0);
    glLoadIdentity();
    glPushMatrix();

    // move to init depth position
    glTranslated(0.0, 0.0, depth);

    // rotate model at specified factor
    // and around the model centre (by translate to avg points)
    glTranslated(0.0, avgY, avgZ);
    glRotated(xRot / 16.0, 1.0, 0.0, 0.0);
    glTranslated(0.0, -avgY, -avgZ);

    glTranslated(avgX, 0.0, avgZ);
    glRotated(yRot / 16.0, 0.0, 1.0, 0.0);
    glTranslated(-avgX, 0.0, -avgZ);

    glTranslated(avgX, avgY, 0.0);
    glRotated(zRot / 16.0, 0.0, 0.0, 1.0);
    glTranslated(-avgX, -avgY, 0.0);

    // drawing color
    glColor3f(0.0f,0.0f,1.0f);  // Color Blue

    // draw points after file is read
    if( drawAble ){

        // draw bounds first
        if(bounding){

            glBegin(GL_LINES);                    // Draw The Cube Using quads
                glVertex3f( maxX, maxY, minZ);    // Top Right Of The Quad (Top)
                glVertex3f( minX, maxY, minZ);    // Top Left Of The Quad (Top)

                glVertex3f( minX, maxY, maxZ);    // Bottom Left Of The Quad (Top)
                glVertex3f( maxX, maxY, maxZ);    // Bottom Right Of The Quad (Top)

                glVertex3f( maxX, minY, maxZ);    // Top Right Of The Quad (Bottom)
                glVertex3f( minX, minY, maxZ);    // Top Left Of The Quad (Bottom)

                glVertex3f( minX, minY, minZ);    // Bottom Left Of The Quad (Bottom)
                glVertex3f( maxX, minY, minZ);    // Bottom Right Of The Quad (Bottom)

                glVertex3f( maxX, maxY, maxZ);    // Top Right Of The Quad (Front)
                glVertex3f( maxX, minY, maxZ);    // Top Left Of The Quad (Front)

                glVertex3f( minX, minY, maxZ);    // Bottom Left Of The Quad (Front)
                glVertex3f( minX, maxY, maxZ);    // Bottom Right Of The Quad (Front)

                glVertex3f( maxX, minY, minZ);    // Top Right Of The Quad (Back)
                glVertex3f( maxX, minY, maxZ);    // Top Left Of The Quad (Back)

                glVertex3f( minX, maxY, minZ);    // Bottom Left Of The Quad (Back)
                glVertex3f( minX, maxY, maxZ);    // Bottom Right Of The Quad (Back)

                glVertex3f( minX, minY, minZ);    // Top Right Of The Quad (Left)
                glVertex3f( minX, maxY, minZ);    // Top Left Of The Quad (Left)

                glVertex3f( minX, minY, minZ);    // Bottom Left Of The Quad (Left)
                glVertex3f( minX, minY, maxZ);    // Bottom Right Of The Quad (Left)

                glVertex3f( maxX, maxY, minZ);    // Top Right Of The Quad (Right)
                glVertex3f( maxX, maxY, maxZ);    // Top Left Of The Quad (Right)

                glVertex3f( maxX, maxY, minZ);    // Bottom Left Of The Quad (Right)
                glVertex3f( maxX, minY, minZ);    // Bottom Right Of The Quad (Right)

            glEnd();                              // End Drawing The Cube

        }

        // if moving flag is not on when object is being moved
        if( ! ( movingClear && movingMouse ) ){
            // check whether point or cube is required for drawing
            if( pointDrawn )
                glPointSize( POINT_SIZE );
            else if( cubeDrawn )
                glPointSize( float( cubeWidth ));

            // now draw all points
            glBegin(GL_POINTS);
            if( fileReader->getEncoding() == 0 ){ // 3d points with associated image coordination
                for( int i = 0; i < fileReader->getNp(); i ++){
                    double r = getColor( (int)fileReader->pointArray[i][3], (int)fileReader->pointArray[i][4], 0);
                    double g = getColor( (int)fileReader->pointArray[i][3], (int)fileReader->pointArray[i][4], 1);
                    double b = getColor( (int)fileReader->pointArray[i][3], (int)fileReader->pointArray[i][4], 2);

                    if( initColor )
                        glColor3d(r, g, b);
                    else
                        glColor3d(((float)pointColor.red()/255), ((float)pointColor.green()/255), ((float)pointColor.blue()/255));

                    glVertex3f(fileReader->pointArray[i][0], -fileReader->pointArray[i][1], -fileReader->pointArray[i][2]);
                }
            }else{ // 3d points with their own color
                for( int i = 0; i < fileReader->getNp(); i ++){

                    if( initColor )
                        glColor3f(fileReader->pointArray[i][3], fileReader->pointArray[i][4], fileReader->pointArray[i][5]);
                    else
                        glColor3d(((float)pointColor.red()/255), ((float)pointColor.green()/255), ((float)pointColor.blue()/255));

                    glVertex3f(fileReader->pointArray[i][0], -fileReader->pointArray[i][1], -fileReader->pointArray[i][2]);
                }
            }
            glEnd();
        }

        glPointSize( POINT_SIZE );

        // draw Camera
        if( cameraEnable ){
            float TW = -0.2f;
            float UNC = -0.005f;
            glColor4f(1.0, 0.0, 0.0, 0.4);
            glBegin(GL_TRIANGLES);
              // top triangle
              glVertex3f( TW-UNC, TW+UNC, TW*3+UNC);
              glVertex3f( -TW+UNC, TW+UNC, TW*3+UNC);
              glVertex3f( 0.0, 0.0+UNC, 0.0-UNC);

              // right triangle
              glVertex3f( TW+UNC, TW-UNC, TW*3+UNC);
              glVertex3f( TW+UNC, -TW+UNC, TW*3+UNC);
              glVertex3f( 0.0+UNC, 0.0, 0.0+UNC);

              // bottom triangle
              glVertex3f( -TW-UNC, -TW-UNC, TW*3+UNC);
              glVertex3f( TW-UNC, -TW-UNC, TW*3+UNC);
              glVertex3f( 0.0, 0.0-UNC, 0.0+UNC);

              // left triangle
              glVertex3f( -TW-UNC, TW-UNC, TW*3+UNC);
              glVertex3f( -TW-UNC, -TW+UNC, TW*3+UNC);
              glVertex3f( 0.0-UNC, 0.0, 0.0+UNC);
            glEnd();

            // a line from camera center to the back of the object
            glColor3f(1.0,0.0,0.0);
            glBegin(GL_LINES);
                glVertex3f(0.0, 0.0, 0.0);
                glVertex3f(0.0, 0.0, maxZ);
            glEnd();
        }

        // mouse Point associated with reference pixel being pointed
        if( mousePoint >= 0 )
        {
            int i = mousePoint;
            float rw = 0.02;
            glColor3f(0.0, 1.0, 0.0);
            glBegin(GL_POLYGON);
                glVertex3f(( fileReader->pointArray[i][0] + rw), -( fileReader->pointArray[i][1] + rw), -fileReader->pointArray[i][2]);
                glVertex3f(( fileReader->pointArray[i][0] - rw), -( fileReader->pointArray[i][1] + rw), -fileReader->pointArray[i][2]);
                glVertex3f(( fileReader->pointArray[i][0] - rw), -( fileReader->pointArray[i][1] - rw), -fileReader->pointArray[i][2]);
                glVertex3f(( fileReader->pointArray[i][0] + rw), -( fileReader->pointArray[i][1] - rw), -fileReader->pointArray[i][2]);
            glEnd();
        }
    }

    glPopMatrix();

}

void Point3dWidget::setMousePoint(int mp){
    mousePoint = mp;
}

double Point3dWidget::getColor(int col, int row, int i){
    // x and y are in 0->255 format
    // obtained from reference image
    // to be converted to 0.0->1.0 format
    return (double) ( (fileReader->imagePixels[col][row][i] ) / 255.0000 );
}

void Point3dWidget::resizeGL(int width, int height)
{
    int side = qMin(width, height);
    glViewport((width - side) / 2, (height - side) / 2, side, side);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-SIZE, +SIZE, -SIZE, SIZE, 1.0, 80.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslated(0.0, 0.0, depth);
}

void Point3dWidget::mousePressEvent(QMouseEvent *event)
{
    movingMouse = true;
    lastPos = event->pos();
    updateGL();
}

void Point3dWidget::mouseReleaseEvent(QMouseEvent *event){
    movingMouse = false;
    updateGL();
}

void Point3dWidget::mouseDoubleClickEvent(QMouseEvent *event){
    initCamera();
}

void Point3dWidget::initCamera(){
    setXRotation(INIT_X);
    setYRotation(INIT_Y);
    setZRotation(INIT_Z);
}

void Point3dWidget::wheelEvent( QWheelEvent *we){
    // check for mouse move direction
    int deltaMoved = we->delta();
    if( deltaMoved < 0 )
        depth -= 0.2f; // decrease depth
    else
        depth += 0.2f; // increase depth

    mainWindow->statusBar()->showMessage(QString("Z coordinate %1").arg(depth));

    updateGL();
}

void Point3dWidget::mouseMoveEvent(QMouseEvent *event)
{
    int dx = event->x() - lastPos.x();
    int dy = event->y() - lastPos.y();

    if (event->buttons() & Qt::LeftButton) {
        setXRotation((int) (xRot + 2.0 * dy));
        setYRotation((int) (yRot + 2.0 * dx));
    } else if (event->buttons() & Qt::RightButton) {
        setXRotation((int) (xRot + 2.0 * dy));
        setZRotation((int) (zRot + 2.0 * dx));
    }
    lastPos = event->pos();
}

void Point3dWidget::normalizeAngle(int *angle)
{
    while (*angle < 0)
        *angle += 360 * 16;
    while (*angle > 360 * 16)
        *angle -= 360 * 16;
}

void Point3dWidget::keyPressEvent(QKeyEvent *e){
    switch( e->key() ){
        case Qt::Key_Right:
            cubeWidth ++;
            emit cubeWidthChanged(cubeWidth);
            break;
        case Qt::Key_Left:
            cubeWidth --;
            emit cubeWidthChanged(cubeWidth);
            break;
        case Qt::Key_Up:
            depth += 0.2f;
            mainWindow->statusBar()->showMessage(QString("Z coordinate %1").arg(depth));
            updateGL();
            break;
        case Qt::Key_Down:
            depth -= 0.2f;
            mainWindow->statusBar()->showMessage(QString("Z coordinate %1").arg(depth));
            updateGL();
            break;
        default:
            break;
    }
}

void Point3dWidget::dragEnterEvent(QDragEnterEvent *event)
{
  if (event->mimeData()->hasFormat("application/x-dnditemdata")) {
    if (event->source() == this) {
      event->setDropAction(Qt::MoveAction);
      event->accept();
    } else {
      event->acceptProposedAction();
    }
  } else {
    event->ignore();
  }
}

void Point3dWidget::dropEvent(QDropEvent *event)
{
  if (event->mimeData()->hasFormat("application/x-dnditemdata")) {
    QByteArray itemData = event->mimeData()->data("application/x-dnditemdata");
    QDataStream dataStream(&itemData, QIODevice::ReadOnly);

    QPixmap pixmap;
    QPoint offset;
    dataStream >> pixmap >> offset;

    QLabel *newIcon = new QLabel(this);
    newIcon->setPixmap(pixmap);
    newIcon->move(event->pos() - offset);
    newIcon->show();
    newIcon->setAttribute(Qt::WA_DeleteOnClose);

    if (event->source() == this) {
      event->setDropAction(Qt::MoveAction);
      event->accept();
    } else {
      event->acceptProposedAction();
    }
  } else {
    event->ignore();
  }
}

---