AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

viewer.cpp

Go to the documentation of this file.

//                            viewer.cpp                                      //
//#include <stdio.h>
#include <qimage.h>
#include <qfileinfo.h>

#include <animal/X3DTK/Qt/mainControllerGUI/MainController.h>
#include "viewer.h"

using namespace qglviewer;

namespace X3DTK
{
  namespace Qt
  {

    Viewer::Viewer()
        : QGLViewer()
        , mainController(NULL)
        , snapshot(false)
        , snapshotFilename("")
        , snapshotCounter(0)
        , videoMode(DISPLAY)
        , selectedPoint(0)
    {
      viewerGUI = new ViewerQt(this);
      viewerGUI->hide();
      setManipulatedFrame( new ManipulatedFrame() );
    }

    Viewer::Viewer(QWidget* q, const char * c)
        : QGLViewer(q, c)
        , mainController(NULL)
        , snapshot(false)
        , snapshotFilename("")
        , snapshotCounter(0)
        , videoMode(DISPLAY)
        , selectedPoint(0)
    {
      viewerGUI = new ViewerQt(this);
      viewerGUI->hide();
      setManipulatedFrame( new ManipulatedFrame() );
    }

    Viewer::~Viewer()
    {
      if (viewerGUI)
      {
        delete viewerGUI;
        viewerGUI = NULL;
      }
    }

    void Viewer::init()
    {
      // Restore previous viewer state.
      restoreFromFile();

      // Redefine keyboard events
      // The default SAVE_SCREENSHOT shortcut is Ctrl+S and this shortcut is used to
      // save x3d file in the MainController. So we need to change it:
      setShortcutKey(QGLViewer::SAVE_SCREENSHOT, Qt::Key_I, Qt::NoButton);

      //portability with other OpenGL versions
#ifdef GL_RESCALE_NORMAL

      glEnable(GL_RESCALE_NORMAL);
#endif
      // GL_LIGHT1 is a directionnal ligth
      glEnable(GL_LIGHT1);
      const GLfloat light_ambient1[4]  =
        {
          0.2, 0.2, 0.2, 1.0
        };
      const GLfloat light_specular1[4] =
        {
          0.3, 0.3, 0.3, 1.0
        };
      const GLfloat light_diffuse1[4]  =
        {
          0.5, 0.5, 0.5, 1.0
        };
      glLightfv(GL_LIGHT1, GL_AMBIENT,  light_ambient1);
      glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular1);
      glLightfv(GL_LIGHT1, GL_DIFFUSE,  light_diffuse1);

      // GL_LIGHT1 follows the camera
      glMatrixMode(GL_MODELVIEW);
      glPushMatrix();
      glLoadIdentity();
      const GLfloat pos1[4] =
        {
          0.0,0.0,0.0,1.0
        };
      glLightfv(GL_LIGHT1, GL_POSITION, pos1);
      glPopMatrix();

      viewAll();

    }

    void Viewer::viewAll()
    {
      updateFrustum();
      showEntireScene();
    }

    void Viewer::updateFrustum()
    {
      if (mainController)
      {
        if ((mainController->getMainScene())->computeBbox())
        {
          setSceneBoundingBox(  (mainController->getMainScene())->getBboxMin().f_data(),
                                (mainController->getMainScene())->getBboxMax().f_data());
        }
      }
    }

    bool Viewer::viewCapture()
    {
      QString videoName = getVideoName();
      if (!(snapshot || !QFile::exists(videoName)))
      {
        // View the video with xine
        QString path = videoName.section('/', 0, -2);
        QString command = "xine " + videoName + " >> " + path + "/xine.log &";
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        std::cerr<<" Background command: "<<command<<std::endl;
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        if (!system(command.ascii()))
          return true;
        else
          return false;
      }
      else
        return false;
    }

    void Viewer::drawAfterAnimation()
    {
      updateGL();


      // Snapshot are done every animation
      if (snapshot && videoMode==ANIMATION)
      {
        static QImage snapshot;
        snapshot = grabFrameBuffer(true);
        char filename[100];
        sprintf(filename, snapshotFilename.latin1(), snapshotCounter++);
        snapshot.save(filename, snapshotFormat);
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        std::cerr<< " SNAPSHOT saved in "<< filename<<std::endl;
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
      }
    }

    bool Viewer::mpeg2encode()
    {
      QString filename_par = snapshotFilename.section('%', 0, 0) + ".par";

      // Count the number of files
      int filesNumber = 0;
      char filename[100];
      sprintf(filename, snapshotFilename.latin1(), filesNumber);
      while (QFile::exists(QString(filename)))
        sprintf(filename, snapshotFilename.latin1(), filesNumber++);
      filesNumber--;

      if (!(  filesNumber==0                  ||
              width()%16!=0 || height()%16!=0 ||
              snapshotFormat!="PPM"           ||
              filename_par.isEmpty()          ||
              QFile::exists(filename_par)     ||
              QFile::exists(getVideoName())))
      {


        QString filepattern  = snapshotFilename.section('.', 0, 0) ;
        std::FILE *f = fopen(filename_par, "w");
        fprintf(f,"\
                MPEG-2 stream 30 frames/sec\n\
                %s        /* name of source files */\n\
                -         /* name of reconstructed images (-: don't store) */\n\
                -         /* name of intra quant matrix file     (-: default matrix) */\n\
                -         /* name of non intra quant matrix file (-: default matrix) */\n\
                -         /* name of statistics file (-: stdout ) */\n\
                2         /* input picture file format: 0=*.Y,*.U,*.V, 1=*.yuv, 2=*.ppm */\n\
                %d        /* number of frames */\n\
                0         /* number of first frame */\n\
                00:00:00:00/* timecode of first frame */\n\
                12        /* N (# of frames in GOP) */\n\
                3         /* M (I/P frame distance) */\n\
                0         /* ISO/IEC 11172-2 stream */\n\
                0         /* 0:frame pictures, 1:field pictures */\n\
                %d        /* horizontal_size */\n\
                %d        /* vertical_size */\n\
                2         /* aspect_ratio_information 1=square pel, 2=4:3, 3=16:9, 4=2.11:1 */\n\
                5         /* frame_rate_code 1=23.976, 2=24, 3=25, 4=29.97, 5=30 frames/sec. */\n\
                3000000.0 /* bit_rate (bits/s) */\n\
                112       /* vbv_buffer_size (in multiples of 16 kbit) */\n\
                0         /* low_delay  */\n\
                0         /* constrained_parameters_flag */\n\
                4         /* Profile ID: Simple = 5, Main = 4, SNR = 3, Spatial = 2, High = 1 */\n\
                8         /* Level ID:   Low = 10, Main = 8, High 1440 = 6, High = 4          */\n\
                0         /* progressive_sequence */\n\
                1         /* chroma_format: 1=4:2:0, 2=4:2:2, 3=4:4:4 */\n\
                1         /* video_format: 0=comp., 1=PAL, 2=NTSC, 3=SECAM, 4=MAC, 5=unspec. */\n\
                5         /* color_primaries */\n\
                5         /* transfer_characteristics */\n\
                5         /* matrix_coefficients */\n\
                %d        ""/* display_horizontal_size */\n\
                %d        /* display_vertical_size */\n\
                0         /* intra_dc_precision (0: 8 bit, 1: 9 bit, 2: 10 bit, 3: 11 bit */\n\
                1         /* top_field_first */\n\
                0 0 0     /* frame_pred_frame_dct (I P B) */\n\
                0 0 0     /* concealment_motion_vectors (I P B) */\n\
                1 1 1     /* q_scale_type  (I P B) */\n\
                1 0 0     /* intra_vlc_format (I P B)*/\n\
                0 0 0     /* alternate_scan (I P B) */\n\
                0         /* repeat_first_field */\n\
                0         /* progressive_frame */\n\
                0         /* P distance between complete intra slice refresh */\n\
                0         /* rate control: r (reaction parameter) */\n\
                0         /* rate control: avg_act (initial average activity) */\n\
                0         /* rate control: Xi (initial I frame global complexity measure) */\n\
                0         /* rate control: Xp (initial P frame global complexity measure) */\n\
                0         /* rate control: Xb (initial B frame global complexity measure) */\n\
                0         /* rate control: d0i (initial I frame virtual buffer fullness) */\n\
                0         /* rate control: d0p (initial P frame virtual buffer fullness) */\n\
                0         /* rate control: d0b (initial B frame virtual buffer fullness) */\n\
                2 2 11 11 /* P:  forw_hor_f_code forw_vert_f_code search_width/height */\n\
                1 1 3  3  /* B1: forw_hor_f_code forw_vert_f_code search_width/height */\n\
                1 1 7  7  /* B1: back_hor_f_code back_vert_f_code search_width/height */\n\
                1 1 7  7  /* B2: forw_hor_f_code forw_vert_f_code search_width/height */\n\
                1 1 3  3  /* B2: back_hor_f_code back_vert_f_code search_width/height */\n\
                "
                , filepattern.latin1(), filesNumber, width(), height(), width(), height() );
        fclose(f);

        // Generation of the video with mpeg2encode
        QString path = filename_par.section('/', 0, -2);
        // Command: mpeg2encode parameterFile.par videoFile.mpg >> videoPath/mpeg2encode.log &
        QString command = "mpeg2encode " + filename_par + " " + getVideoName() + " >> " + path + "/mpeg2encode.log &";
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        std::cerr<<" Background command: "<<command<<std::endl;
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        if (system(command.ascii()))
          return false;
        else
          return true;
      }
      else
        return false;
      //std::cerr<<" Warning: the snapshot files format has to be PPM to create a video with mpeg2encode !"<<std::endl;
    }

    bool Viewer::xvidcap()
    {
      if (videoMode==SCREEN)
      {
        // Verify the name of the files and if they existe
        char filename[100];
        sprintf(filename, snapshotFilename.latin1(), 0);
        if (  snapshotFilename.isEmpty()  ||
              snapshotFormat.isEmpty()    ||
              QFile::exists(QString(filename)))
          return false;

        // Command: xvidcap --fps 25 --file "video/video%04d.ppm" --cap_size 320x240 --time 0 &
        char command[500];
        sprintf(command, "xvidcap --fps 25 --file \"%s\" --cap_geometry %dx%d --time 0 &", snapshotFilename.latin1(), this->width(), this->height());
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        std::cerr<<" Background command: "<<command<<std::endl;
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        if (system(command))
          return false;
        else
          return true;
      }
      return false;
    }


    void Viewer::setMainController(::MainController * mainController)
    {
      this->mainController = mainController;
      viewerGUI->reparent(mainController, ::Qt::WType_Dialog, QPoint(0,0));
    }

    void Viewer::draw()
    {
      //std::cerr<< "Viewer::draw()"<<std::endl;

      //drawLight(GL_LIGHT1);

      //  this->show();
      //  this->raise();

      // Draws the scene.
      if (mainController)
      {
        (mainController->getMainScene())->draw();
    }

    if( selectedPoint )
    {
        selectedPoint->draw();
    }
    
      //   if( manipulatedFrame() ){
      //    // Save the current model view matrix
      //    glPushMatrix();
      //    // Multiply matrix to get in the frame coordinate system.
      //    glMultMatrixd(manipulatedFrame()->matrix());
      //    // Scale the drawings
      //    glScalef(3, 3, 3);
      //    // Draw an axis using the QGLViewer static function
      //    drawAxis();
      //    // Restore the original (world) coordinate system
      //    glPopMatrix();
      //    }

    }

    void Viewer::postDraw()
    {
      QGLViewer::postDraw();

      // Snapshot are done every display
      if (snapshot && videoMode==DISPLAY)
      {
        static QImage snapshot;
        snapshot = grabFrameBuffer(true);
        char filename[100];
        sprintf(filename, snapshotFilename.latin1(), snapshotCounter++);
        snapshot.save(filename, snapshotFormat);
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
        std::cerr<< " SNAPSHOT saved in "<< filename<<std::endl;
        std::cerr<< "--------------------------------------------------------------"<<std::endl;
      }
    }

    QString Viewer::helpString() const
    {
      QString text("<h2>X 3 D T K :: Q t :: V i e w e r</h2>");
      text += "Use the mouse to move the camera around the object. ";
      text += "You can revolve around, zoom and translate with the three buttons. ";
      text += "Left and middle buttons pressed together rotate around the camera z axis<br><br>";

      text += "Press <b>F</b> to display the frame rate, <b>A</b> for the world axis, ";
      text += "<b>Alt+Return</b> for full screen mode and <b>I</b> to save a single snapshot.<br><br>";

      text += "Press <b>R</b> to display the viewer property where you can set:<br>";
      text += "       - the viewer's size and,<br>";
      text += "       - the video capture.<br><br>";

      text += "Press <b>V</b> to view all the x3d scene.<br><br>";

      text += "A double click aligns the closer axis with the camera (left, if close enough), fits ";
      text += "the zoom of the camera (middle) or re-center the scene (right).<br>";
      text += "A left double click while right button is pressed defines the <i>revolveAroundPoint</i>.";
      text += "With middle button pressed instead, it zooms on the pixel.<br><br>";

      text += "See also the <b>Shortcuts</b> and <b>Mouse</b> tabs and the documentation web pages:<br>";
      text += "               http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer/index.html<br>";
      return text;
    }

    //-----------Mouse and key board events-------------
    void Viewer::keyPressEvent(QKeyEvent *e)
    {
      if (e->key()==Qt::Key_V)
        viewAll();
      else if( e->key()==Qt::Key_Control  )
      {
        interactionMode = SELECT_OBJECT;
        //std::cout<<"Viewer::keyPressEvent switch to SELECT_OBJECT mode"<<std::endl;
        e->accept();
      }
      else if( e->key()==Qt::Key_F  )
        std::cerr<<" Sorry: the key F (to display the frame rate on the QGLViewer window) makes the program abort. So it is temporaly disabled !"<< std::endl;
      else
        QGLViewer::keyPressEvent(e);

      //mainController->keyPressEvent(e);
    }

    void Viewer::keyReleaseEvent(QKeyEvent *e)
    {
      QGLViewer::keyReleaseEvent(e);
      if ( e->key()==Qt::Key_Control  )
      {
        interactionMode = MOVE_CAMERA;
        e->accept();
        //std::cout<<"Viewer::keyReleaseEvent switch to MOVE_CAMERA mode"<<std::endl;
      }
      
      //mainController->keyReleaseEvent(e);
    }

    void Viewer::mouseDoubleClickEvent(QMouseEvent * e)
    {
      QGLViewer::mouseDoubleClickEvent(e);

      //mainController->mouseDoubleClickEvent(e);
    }

    void Viewer::mouseMoveEvent(QMouseEvent * e)
    {
      //std::cout<<"Viewer::mouseMoveEvent"<<std::endl;
      QGLViewer::mouseMoveEvent(e);
      if( selectedPoint && interactionMode == SELECT_OBJECT )
      {
        //if( ! manipulatedFrame() ) std::cerr<<" selectedPoint but no manipulatedFrame() !!!"<< std::endl;
        float x,y,z;
        manipulatedFrame()->getPosition(x,y,z);
        //std::cout<<"Viewer::mouseMoveEvent, new manipulatedFrame origin: " <<  x <<", "<< y <<", "<< z << std::endl;
        selectedPoint->moveTo(x,y,z);
        e->accept();
      }

      //  // The viewer do not handle the event
      //  e->ignore();
      //mainController->mouseMoveEvent(e);
    }

    void Viewer::mousePressEvent(QMouseEvent * e)
    {
      //std::cout<<"Viewer::mousePressEvent"<<std::endl;
      QGLViewer::mousePressEvent(e);
      if( interactionMode == SELECT_OBJECT && e->button()==Qt::RightButton)
      {
        float dir[3], orig[3], threshold=0.001;
        camera()->convertClickToLine(e->x(), e->y(), orig, dir );
        if( (selectedPoint = mainController->pickPoint(orig,dir,threshold)) )
        {
          //std::cout<<"Viewer::mousePressEvent selected an object, "<< std::endl;
          selectedPoint->print();

          // check if the item is already manipulated, to avoid redundancy.
          ItemList::const_iterator
          i=manipulatedObjects.begin(),
            iend = manipulatedObjects.end();
          while( i != iend && !(**i == selectedPoint ) )
            ++i;
          if( i==iend ) // not in the list
          {
            manipulatedObjects.push_back(selectedPoint);
          }
          else // use the Item already in the list
          {
            delete selectedPoint;
            selectedPoint = *i;
          }

          // manipulate the item
          float x,y,z;
          selectedPoint->getPoint(x,y,z);
          selectedPoint->moveTo(x,y,z);
          manipulatedFrame()->setTranslation(x,y,z);
          e->accept();
        }
        //else std::cout<<"Viewer::mousePressEvent selected no object, "<< std::endl;
      }
      //else std::cout<<"interactionMode is not SELECT_OBJECT"<<std::endl;
      //mainController->mousePressEvent(e);
    }

    void Viewer::mouseReleaseEvent(QMouseEvent * e)
    {
      QGLViewer::mouseReleaseEvent(e);
      if( interactionMode == SELECT_OBJECT && e->button()==Qt::RightButton && selectedPoint)
      {
        manipulatedObjects.remove( selectedPoint );
        delete selectedPoint;
        selectedPoint = 0;
        e->accept();
      }
      //mainController->mouseReleaseEvent(e);
    }
    //-----------End of mouse and key board events-------------

    bool Viewer::setSnapshot(bool b)
    {

      if(b)
      {
        snapshot = true;
        snapshotCounter=0;
        char filename[100];
        sprintf(filename, snapshotFilename.latin1(), 0);
        if (  snapshotFilename.isEmpty()  ||
              snapshotFormat.isEmpty()    ||
              QFile::exists(QString(filename)))
          snapshot = false;

      }
      else
        snapshot=false;

      return snapshot;
    }

    void Viewer::setSnapshotFilename(QString s)
    {
      snapshotFilename = s;
      if (snapshotFilename.isEmpty())
      {
        std::cerr<<" Warning: the snapshot file name is empty !"<< std::endl;
        return;
      }

      // Get the extension
      QString sQt(s);
      QFileInfo info(sQt);
      snapshotFormat = (info.extension(false)).upper();

      // Check that extension has been provided and is an available format handled by Qt
      QStringList formatList = QImage::outputFormatList();
      if (!formatList.contains(snapshotFormat))
      {
        std::cerr<<" Warning: the extension is not valid !"<< std::endl;
        snapshotFormat = "";
      }

    }

    QString Viewer::getVideoName()
    {
      QString prefix(snapshotFilename.section('%', 0, 0));
      if(prefix.isEmpty())
        return "";
      else
        return prefix+".mpg";
    }

    void Viewer::setVideoName(QString fileName)
    {
      fileName = fileName.remove(".mpg");
      fileName = fileName.remove(".MPG");
      setSnapshotFilename(fileName+"%04d.ppm");
    }

  }// Qt
}// X3DTK

---