opengl_viewer.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 * Point Cloud Library (PCL) - www.pointclouds.org
 * Copyright (c) 2009-2012, Willow Garage, Inc.
 * Copyright (c) 2012-, Open Perception, Inc.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of the copyright holder(s) nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * $Id$
 *
 */

#ifndef PCL_APPS_IN_HAND_SCANNER_OPENGL_VIEWER_H
#define PCL_APPS_IN_HAND_SCANNER_OPENGL_VIEWER_H

#include <string>

#include <QGLWidget>

#include <pcl/pcl_exports.h>
#include <pcl/common/time.h>
#include <pcl/apps/in_hand_scanner/boost.h>
#include <pcl/apps/in_hand_scanner/common_types.h>
#include <pcl/apps/in_hand_scanner/eigen.h>

namespace pcl
{
  namespace ihs
  {
    namespace detail
    {
      class FaceVertexMesh
      {
        public:

          class Triangle
          {
            public:

              Triangle () : first (0), second (0), third (0) {}
              Triangle (const unsigned int first, const unsigned int second, const unsigned int third)
                : first (first), second (second), third (third)
              {
              }

              unsigned int first;
              unsigned int second;
              unsigned int third;
          };

          FaceVertexMesh ();

          FaceVertexMesh (const Mesh& mesh, const Eigen::Isometry3d& T);

          typedef pcl::ihs::PointIHS         PointIHS;
          typedef pcl::ihs::CloudIHS         CloudIHS;
          typedef pcl::ihs::CloudIHSPtr      CloudIHSPtr;
          typedef pcl::ihs::CloudIHSConstPtr CloudIHSConstPtr;

          CloudIHS               vertices;
          std::vector <Triangle> triangles;
          Eigen::Isometry3d      transformation;

        public:

          EIGEN_MAKE_ALIGNED_OPERATOR_NEW
      };
    } // End namespace detail

    class PCL_EXPORTS OpenGLViewer : public QGLWidget
    {
      Q_OBJECT

      public:

        typedef pcl::PointXYZRGBNormal              PointXYZRGBNormal;
        typedef pcl::PointCloud <PointXYZRGBNormal> CloudXYZRGBNormal;
        typedef CloudXYZRGBNormal::Ptr              CloudXYZRGBNormalPtr;
        typedef CloudXYZRGBNormal::ConstPtr         CloudXYZRGBNormalConstPtr;

        typedef pcl::ihs::Mesh         Mesh;
        typedef pcl::ihs::MeshPtr      MeshPtr;
        typedef pcl::ihs::MeshConstPtr MeshConstPtr;

        typedef enum MeshRepresentation
        {
          MR_POINTS, 
          MR_EDGES,  
          MR_FACES   
        } MeshRepresentation;

        typedef enum Coloring
        {
          COL_RGB,       
          COL_ONE_COLOR, 
          COL_VISCONF    
        } Coloring;

        class BoxCoefficients
        {
          public:

            BoxCoefficients ()
              : x_min (0), x_max (0),
                y_min (0), y_max (0),
                z_min (0), z_max (0),
                transformation (Eigen::Isometry3d::Identity ())
            {
            }

            BoxCoefficients (const float x_min, const float x_max,
                             const float y_min, const float y_max,
                             const float z_min, const float z_max,
                             const Eigen::Isometry3d& T)
              : x_min (x_min), x_max (x_max),
                y_min (y_min), y_max (y_max),
                z_min (z_min), z_max (z_max),
                transformation (T)
            {
            }

            float x_min; float x_max;
            float y_min; float y_max;
            float z_min; float z_max;
            Eigen::Isometry3d transformation;

          public:

            EIGEN_MAKE_ALIGNED_OPERATOR_NEW
        };

        explicit OpenGLViewer (QWidget* parent=0);

        ~OpenGLViewer ();

        bool
        addMesh (const MeshConstPtr& mesh, const std::string& id, const Eigen::Isometry3d& T = Eigen::Isometry3d::Identity ());

        bool
        addMesh (const CloudXYZRGBNormalConstPtr& cloud, const std::string& id, const Eigen::Isometry3d& T = Eigen::Isometry3d::Identity ());

        bool
        removeMesh (const std::string& id);

        void
        removeAllMeshes ();

        void
        setBoxCoefficients (const BoxCoefficients& coeffs);

        void
        setDrawBox (const bool enabled);

        bool
        getDrawBox () const;

        void
        setPivot (const Eigen::Vector3d& pivot);

        void
        setPivot (const std::string& id);

        void
        stopTimer ();

        void
        setVisibilityConfidenceNormalization (const float vis_conf_norm);

        virtual QSize
        minimumSizeHint () const;

        virtual QSize
        sizeHint () const;

        void
        setScalingFactor (const double scale);

      public slots:

        void
        timerCallback ();

        void
        resetCamera ();

        void
        toggleMeshRepresentation ();

        void
        setMeshRepresentation (const MeshRepresentation& representation);

        void
        toggleColoring ();

        void
        setColoring (const Coloring& coloring);

      protected:

        class FPS
        {
          public:

            FPS () : fps_ (0.) {}

            inline double& value ()       {return (fps_);}
            inline double  value () const {return (fps_);}

            inline std::string
            str () const
            {
              std::stringstream ss;
              ss << std::setprecision (1) << std::fixed << fps_;
              return (ss.str ());
            }

          protected:

            ~FPS () {}

          private:

            double fps_;
        };

        template <class FPS> void
        calcFPS (FPS& fps) const
        {
          static pcl::StopWatch sw;
          static unsigned int count = 0;

          ++count;
          if (sw.getTimeSeconds () >= .2)
          {
            fps.value () = static_cast <double> (count) / sw.getTimeSeconds ();
            count = 0;
            sw.reset ();
          }
        }

        virtual void
        paintEvent (QPaintEvent* event);

      private:

        typedef Eigen::Matrix <unsigned char, 3, 1             > Color;
        typedef Eigen::Matrix <unsigned char, 3, Eigen::Dynamic> Colors;
        typedef Eigen::Matrix <unsigned char, 3, 256           > Colormap;

        typedef boost::unordered_map <std::string, CloudXYZRGBNormalPtr> CloudXYZRGBNormalMap;

        typedef pcl::ihs::PointIHS         PointIHS;
        typedef pcl::ihs::CloudIHS         CloudIHS;
        typedef pcl::ihs::CloudIHSPtr      CloudIHSPtr;
        typedef pcl::ihs::CloudIHSConstPtr CloudIHSConstPtr;

        typedef pcl::ihs::detail::FaceVertexMesh                      FaceVertexMesh;
        typedef boost::shared_ptr <      FaceVertexMesh>              FaceVertexMeshPtr;
        typedef boost::shared_ptr <const FaceVertexMesh>              FaceVertexMeshConstPtr;
        typedef boost::unordered_map <std::string, FaceVertexMeshPtr> FaceVertexMeshMap;

        bool
        getMeshIsAdded (const std::string& id);

        void
        calcPivot ();

        void
        drawMeshes ();

        void
        drawBox ();

        void
        initializeGL ();

        void
        setupViewport (const int w, const int h);

        void
        resizeGL (int w, int h);

        void
        mousePressEvent (QMouseEvent* event);

        void
        mouseMoveEvent (QMouseEvent* event);

        void
        wheelEvent (QWheelEvent* event);

        // Members

        boost::mutex mutex_vis_;

        boost::shared_ptr <QTimer> timer_vis_;

        Colormap colormap_;

        float vis_conf_norm_;

        FaceVertexMeshMap drawn_meshes_;

        MeshRepresentation mesh_representation_;

        Coloring coloring_;

        bool draw_box_;

        BoxCoefficients box_coefficients_;

        double scaling_factor_;

        Eigen::Quaterniond R_cam_;

        Eigen::Vector3d t_cam_;

        Eigen::Vector3d cam_pivot_;

        std::string cam_pivot_id_;

        bool mouse_pressed_begin_;

        int x_prev_;

        int y_prev_;

      public:

        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    };
  } // End namespace ihs
} // End namespace pcl

// http://doc.qt.digia.com/qt/qmetatype.html#Q_DECLARE_METATYPE
Q_DECLARE_METATYPE (pcl::ihs::OpenGLViewer::MeshRepresentation)
Q_DECLARE_METATYPE (pcl::ihs::OpenGLViewer::Coloring)

#endif // PCL_APPS_IN_HAND_SCANNER_OPENGL_VIEWER_H