Lab 10: Qt Photon Visualizer

Objectives

Background

1. You can think of the GUI toolkit as a kind of visual interface to otherwise normal processing of data. One of the main differences between the GUI toolkit and command-line processing is that the GUI program is event-driven. The GUI program basically sits idle waiting for user events, which are key strokes, mouse motions, mouse button clicks, and window events such as window resize, or window exposure, to name a few.
2. Our basic template for Qt interaction follows the basic Qt OpenGL tutorials (e.g., the Hello GL example).
3. OpenGL is the graphics library that we use to display graphics primitives, in this case GL_POINTS which are just 3D points in space (the 3D world).
4. Our graphics window, the main Qt window that "listens" to user events can also process OpenGL commands.
   • OpenGL user events:
     • initializeGL()
       This method is called once, upon window creation. Here not much needs to be done except for setting up the color that will be used to clear the window:

       			glClearColor(0.0, 0.0, 0.0, 0.0);
       			

     • resizeGL(int w, int h)
       This method is called whenever the window is resized, including when the window is first realized. Here you need to set up the viewport as well as the initial view and model transformations:

       			// set up the OpenGL view port
       			glViewport(0,0,w,h);
       
       			// set up the view transformation
       			glMatrixMode(GL_PROJECTION);
       			glLoadIdentity();
       			gluPerspective(45.0,8.0/6.0,0.1,100.0);
       			
       			// set up the model transformation
       			glMatrixMode(GL_MODELVIEW);
       			glLoadIdentity();
       			

       Note that the parameters provided to gluPerspective match those in our usual model.txt scene file.
     • paintGL()
       This is the main drawing routine—note two very important aspects of this method:
       • this is not called continuously (it can be, e.g., during physical simulations like games), but usually only when the scene needs to be updated, e.g., when the scene changes or in response to user events
       • this function is never called directly but is itself called in reponse to the redraw event—to issue a redraw event, call updateGL(); DO NOT CALL paintGL() DIRECTLY!
       Thinking in "re-entrant" terms, this function can, however, be called at any time during the program's state. So, you have to set this up so that it responds when there is data to draw and when there isn't (so it doesn't seg fault with an empty data structure):

       			// draw to the back buffer
       			glDrawBuffer(GL_BACK);
       			glClear(GL_COLOR_BUFFER_BIT);
       			glColor4f(0.0,0.0,0.0,0.0);
       
       			// model/view transformation
       			glMatrixMode(GL_MODELVIEW);
       			glLoadIdentity();
       			gluLookAt(4.0,3.0,6.0,	// camera position
       			          4.0,3.0,0.0,	// view direction
       			          0.0,1.0,0.0);	// view up vector (tilt)
       
       			// render photons
       			glColor4f(0.8,0.8,0.8,0.8);
       			for(int i=0; i<(int)photons.size(); i++) {
       			  glPointSize(1.0);
       			  glBegin(GL_POINTS);
       			  glVertex3f((*photons[i])[0],
                                            (*photons[i])[1],
                                            (*photons[i])[2]);
       			  glEnd();
       			}
       			

       Notice that the parameters provided to gluLookAt match those in our usual model.txt scene file.

       Notice also how the photon coordinates are accessed—remember that photons is a std::vector<photon_t* >, an STL vector holding pointers to photon_t objects.

   • Qt user events (public slots:):
     • mouseMoveEvent(QMouseEvent* e)
       In this event handler, there isn't much to do, so we can simply accept the event and send a redraw event:

       			e->accept();
       			updateGL();
       			

     • update()
       Ordinarily here we could do various activities related to real-time simulations, but in this specific instance we just issue a redraw event:

       			updateGL();
       			

     • imgSaveAs()
       Here, we want to grab what is in the OpenGL back buffer, then use one of Qt's very convenient features, the file browser to select the file name where we want to write the screen captured image:

       			glReadBuffer(GL_BACK);
       
       			QImage img = QGLWidget::grabFrameBuffer(true);
       
       			QString qfilename = QFileDialog::getSaveFileName(this,
                                           tr("Save Image As..."),
                                           "./",
                                           tr("Images (*.png)"));
       
       			// get QImage to write itself
       			if(!qfilename.isEmpty()) img.save(qfilename,"PNG");
       			

     • fileOpen()
       This is similar to imgSaveAs() except that we read in a file full of photons—this is why you need to have operator>> defined for the photon_tclass:

       			QString qfilename = QFileDialog::getOpenFileName(this,
                                           tr("Open File"),
                                           "./",
                                           tr("Point Files (*.pts)"));
       
       			std::ifstream photons_ifs;    // input file
       			photon_t      *ph;            // ptr to photon
       
       			if(!qfilename.isEmpty()) {
       
       			  // open file if file dialog returned something
       			  photons_ifs.open(qfilename.toStdString().c_str());
       
       			  // read one photon per line
       			  while(!photons_ifs.eof()) {
       			    ph = new photon_t();      // allocate new photon
       			    photons_ifs >> ph;        // read it in
       			    photons.push_back(ph);    // add to photon array
       			  }
       			  photons_ifs.close();
       			}
       
       			updateGL();
       			

       Notice the call to updateGL() to refresh the drawable.

Assignment

1. Use the given photons.pts to test your Qt photon viewer.
2. For the Qt app, your best bet is to follow the Hello GL tutorial and create the following files:
   • glwinobj.h, glwinobj.cpp: these hold the interface and implementation of the main window (I called mine GLObjectWindow which is derived from QWidget) which contains the menubar as well as the GL window.
   • gltexobj.h, gltexobj.cpp: these hold the interface and implementation of just the GL window (I called mine GLTexobj following the Qt tutorial, which is derived from QGLWidget). This object handles all the user events as well, the GLObjectWindow connects connects the user event signals to GLTexobj's slots.
If all the Qt is set up properly, the following main() is one way to start the program (Qt documentation suggests an alternate approach using something like the QMainWindow but the following will work just as well, but feel free to use either):

int main(int argc, char **argv)
{
    QApplication::setColorSpec(QApplication::CustomColor);
    QApplication app(argc,argv);

  if(!QGLFormat::hasOpenGL()) {
    qWarning( "This system has no OpenGL support. Exiting." );
    return -1;
  }

  // Create OpenGL format
  QGLFormat f;
  f.setDoubleBuffer(TRUE); f.setRgba(TRUE); f.setDepth(TRUE);
  QGLFormat::setDefaultFormat(f);

  GLObjectWindow* w = new GLObjectWindow;

  // set size...
  w->resize( 640, 480 );
  w->show();
  // ... or go full screen
  //w->showFullScreen();

  int result = app.exec();
  delete w;
  return result;
}
	

Turn in

1. A README file containing
   1. Course id--section no
   2. Name
   3. Lab description
   4. Brief solution description (e.g., program design, description of algorithm, etc., however appropriate).
   5. Lessons learned, identified interesting features of your program
   6. Any special usage instructions
2. Makefile
3. source code (.h headers and .cpp source)
4. object code (do a make clean before tar)

How to hand in