SimpleViewer.h

Go to the documentation of this file.

// Copyright (c) 2012-2019 University of Lyon and CNRS (France).
// All rights reserved.
//
// This file is part of MEPP2; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#pragma once
 
#if __GNUC__ >= 9
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif
 
#include <osgViewer/ViewerEventHandlers>
 
#if __GNUC__ >= 9
#pragma GCC diagnostic pop
#endif
 
#include "Base/Color.hpp"
#include "Visualization/BaseViewerOSG.h"
 
#include "Base/Texture.h"
 
#include "Visualization/Helpers/OSGHelpers.h"
#include "Visualization/OSG/Visitor/DataVisitor.h"
 
#include <osg/Material>
 
#include <osg/Texture2D>
#include <osgDB/ReadFile>
 
// Generic mesh iterators
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include "FEVV/Wrappings/Graph_traits_extension.h"
#include "FEVV/Wrappings/Geometry_traits.h"
#include <CGAL/boost/graph/properties.h> // included in External folder
 
#include <iostream>
#include <map>
#include <utility>
 
#include <Eigen/Dense> // for Eigen::matrix
 
#ifdef FEVV_USE_CGAL
#include "FEVV/Wrappings/properties_polyhedron_3.h"
#include "FEVV/Wrappings/properties_surface_mesh.h"
#include "FEVV/Wrappings/properties_linear_cell_complex.h"
#include "FEVV/Wrappings/properties_cgal_point_set.h"
#include "FEVV/Wrappings/Graph_traits_extension_cgal_polyhedron_3.h"
#include "FEVV/Wrappings/Graph_traits_extension_cgal_surface_mesh.h"
#include "FEVV/Wrappings/Graph_traits_extension_cgal_linear_cell_complex.h"
#include "FEVV/Wrappings/Graph_traits_extension_cgal_point_set.h"
#endif
 
#ifdef FEVV_USE_OPENMESH
#include "FEVV/Wrappings/properties_openmesh.h"
#include "FEVV/Wrappings/Graph_traits_extension_openmesh.h"
#endif
 
#ifdef FEVV_USE_AIF
#include "FEVV/Wrappings/properties_aif.h"
#include "FEVV/Wrappings/Graph_traits_extension_aif.h"
#endif
 
#ifdef FEVV_USE_PCL
#include "FEVV/Wrappings/properties_pcl_point_cloud.h"
#include "FEVV/Wrappings/Graph_traits_extension_pcl_point_cloud.h"
#endif
 
namespace FEVV {
 
 
#ifdef FEVV_USE_CGAL
  inline
  std::string getDatastructureName(FEVV::MeshPolyhedron* /*m*/)
  {
    return "POLYHEDRON";
  }
 
  inline
  std::string getDatastructureName(FEVV::MeshSurface* /*m*/)
  {
    return "SURFACEMESH";
  }
 
  inline
  std::string getDatastructureName(FEVV::MeshLCC* /*m*/)
  {
    return "LCC";
  }
 
  inline
  std::string getDatastructureName(FEVV::CGALPointSet* /*m*/)
  {
    return "CGALPOINTSET";
  }
#endif //FEVV_USE_CGAL
 
#ifdef FEVV_USE_OPENMESH
  inline
  std::string getDatastructureName(FEVV::MeshOpenMesh* /*m*/)
  {
    return "OPENMESH";
  }
#endif //FEVV_USE_OPENMESH
 
#ifdef FEVV_USE_AIF
  inline
  std::string getDatastructureName(FEVV::MeshAIF* /*m*/)
  {
    return "AIF";
  }
#endif //FEVV_USE_AIF
 
#ifdef FEVV_USE_PCL
  inline
  std::string getDatastructureName(FEVV::PCLPointCloud* /*m*/)
  {
    return "PCLPOINTCLOUD";
  }
#endif //FEVV_USE_PCL
 
 
class MixedMeshesVector
{
public:
  typedef  std::pair<void*, std::string>  VoidMeshPtr;
 
  void push_back(VoidMeshPtr &ptr)
  {
    storage.push_back(ptr);
  }
 
  template< typename MeshT >
  void push_back(MeshT *m)
  {
    auto pair = std::make_pair(static_cast< void* >(m),
                               getDatastructureName(m));
    storage.push_back(pair);
    std::cout << "[SimpleViewer] mesh " << pair.first
              << " stored with datastructure " << pair.second
              << std::endl;
  }
 
  std::size_t size(void)
  {
    return storage.size();
  }
 
  VoidMeshPtr&  operator[](std::size_t pos)
  {
    return storage[pos];
  }
 
protected:
  std::vector< VoidMeshPtr > storage;
};
 
 
class SimpleViewer : public BaseViewerOSG
{
public:
  SimpleViewer();
 
  ~SimpleViewer();
 
  void init() override;
 
  bool isInit() const override;
 
  bool isValid() const override;
 
  // bool isSelected() const override; MT -> JL : why this function ?
 
  // void attach( Widget* _widget );
 
  bool changeBackgroundColor(const Color &_color) override;
 
  bool saveScreenshot(const std::string &_name) override;
 
  void addModel(Model *_geode) override;
 
  void addGroup(Group *_group) override;
 
  void setNodeSelected(osg::Node *_geode, bool isSelected) override;
  bool isNodeSelected(osg::Node *_geode) override;
 
  std::vector< osg::Geode * > getSelectedGeodes();
 
  std::vector< osg::Geode * > getGeodes();
 
  MixedMeshesVector getSelectedMeshes();
 
  MixedMeshesVector getMeshes();
 
  size_t getMeshId(const void *mesh_ptr);
 
  std::vector< std::string > getSelectedMeshesNames();
 
  std::vector< std::string > getMeshesNames();
 
  std::vector< PMapsContainer * > getSelected_properties_maps();
 
  std::vector< PMapsContainer * > get_properties_maps();
 
 
  std::vector< osg::Group * > getSelectedDraggers1();
  std::vector< osg::Group * > getDraggers1();
 
  std::vector< osg::Group * > getSelectedDraggers2();
  std::vector< osg::Group * > getDraggers2();
 
 
#if 0 //TODO-elo-rm-?-ask_MTO
 
  HalfedgeGraph *getMesh(unsigned int _position);
#endif
 
  DataModelVector *getDataModel() override;
 
 
  osg::Matrix getTransformMatrixOsg(unsigned int position);
  Eigen::Matrix4d getTransformMatrixEigen(unsigned int position);
 
  void resetTransformMatrix(unsigned int position);
 
 
  template< typename HalfedgeGraph, typename PointMap >
  osg::ref_ptr< osg::Group >
  createMesh(HalfedgeGraph *_g,
             PMapsContainer *_pmaps,
             PointMap *_pm,
             std::string _mesh_file = std::string(""),
             osg::ref_ptr< osg::Group > _group = new osg::Group);
 
  template< typename HalfedgeGraph, typename PointMap >
  void drawMesh(HalfedgeGraph *_g,
                PMapsContainer *_pmaps,
                PointMap *_pm,
                std::string _mesh_file = std::string(""));
 
  template< typename HalfedgeGraph, typename PointMap >
  void redrawMesh(HalfedgeGraph *_g,
                  PMapsContainer *_pmaps,
                  PointMap *_pm = nullptr,
                  std::string _mesh_file = std::string(""));
 
  template< typename HalfedgeGraph >
  void centerMesh(HalfedgeGraph *_g);
 
  osg::Matrix getMatrixVP();
  void setMatrixVP(osg::Matrix matrix);
 
  template< typename HalfedgeGraph >
  void draw_or_redraw_mesh(/*const */ HalfedgeGraph *_g,
                           /*const */ PMapsContainer *_pmaps,
                           bool _redraw = false,
                           bool _recomputeNT_if_redraw = false,
                           std::string _mesh_filename = std::string(""),
                           bool _recreateOSGobj_if_redraw = true,
                           float _step = 0.);
 
  void activate_time_mode();
  void activate_space_mode();
 
  void updateSWModelList();
 
  osg::Node *addDraggersToScene(osg::Node *scene,
                                const std::string &nameDrag1,
                                float fScaleDrag1,
                                char keyDrag1,
                                const std::string &nameDrag2,
                                float fScaleDrag2,
                                char keyDrag2);
 
protected:
  template< typename HalfedgeGraph, typename PointMap >
  void internal_createMesh(
      osg::Geode *&geode,
      HalfedgeGraph *_g,
      PMapsContainer *_pmaps,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesL,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesP,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_edges,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_vertices,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_normals,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArraysF,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &tangentsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec2Array > > &texcoordsArrays,
      PointMap *_pm,
      std::string _mesh_file = std::string(""));
  template< typename HalfedgeGraph, typename PointMap >
  osg::Geode *internal_createMesh(
      HalfedgeGraph *_g,
      PMapsContainer *_pmaps,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesL,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesP,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_edges,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_vertices,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_normals,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArraysF,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &tangentsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec2Array > > &texcoordsArrays,
      PointMap *_pm,
      std::string _mesh_file = std::string(""));
 
  template< typename PointCloud, typename PointMap >
  void internal_createMesh_pointcloud(
      osg::Geode *&geode,
      PointCloud *_g,
      PMapsContainer *_pmaps,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesL,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometriesP,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_edges,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_vertices,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_normals,
      std::vector< osg::ref_ptr< osg::Geometry > > &geometries_custom_vectorss,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &vertexArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArraysF,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &normalsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec3Array > > &tangentsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_edges,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_vertices,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_normals,
      std::vector< osg::ref_ptr< osg::Vec4Array > > &colorsArrays_custom_vectors,
      std::vector< osg::ref_ptr< osg::Vec2Array > > &texcoordsArrays,
      PointMap *_pm,
      std::string _mesh_file = std::string(""));
 
private:
  template< typename HalfedgeGraph,
            typename VertexNormalMap,
            typename VertexTangentMap,
            typename VertexColorMap,
            typename FaceColorMap,
            typename VertexUVMap,
            typename HalfedgeUVMap,
            typename FaceMaterialMap >
  void internal_loadShadedMesh(
      osg::Geode *_geode,
      HalfedgeGraph *_g,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_edges,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_vertices,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_normals,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_custom_vectors,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_normals,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_custom_vectors,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_tangentsArrays,
      const std::vector< osg::ref_ptr< osg::Vec2Array > > &_texcoordsArrays,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_normals,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_custom_vectors,
      std::size_t _m_mm_size,
      VertexNormalMap *_vt_nm,
      VertexTangentMap *_vt_tm,
      VertexColorMap *_vt_cm,
      FaceColorMap *_f_cm,
      VertexUVMap *_vt_uv_m,
      HalfedgeUVMap *_het_uv_m,
      FaceMaterialMap *_m_mm,
      bool has_face_color_map);
 
  template< typename HalfedgeGraph,
            typename VertexNormalMap,
            typename VertexColorMap,
            typename FaceColorMap,
            typename VertexUVMap,
            typename HalfedgeUVMap,
            typename FaceMaterialMap >
  void internal_loadLegacyMesh(
      osg::Geode *_geode,
      HalfedgeGraph *_g,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_edges,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_vertices,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_normals,
      const std::vector< osg::ref_ptr< osg::Geometry > > &_geometries_custom_vectors,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_normals,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_vertexArrays_custom_vectors,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec3Array > > &_normalsArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec2Array > > &_texcoordsArrays,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_edges,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_vertices,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_normals,
      const std::vector< osg::ref_ptr< osg::Vec4Array > > &_colorsArrays_custom_vectors,
      std::size_t _m_mm_size,
      int _texture_type,
      VertexNormalMap *_vt_nm,
      VertexColorMap *_vt_cm,
      FaceColorMap *_f_cm,
      VertexUVMap *_vt_uv_m,
      HalfedgeUVMap *_het_uv_m,
      FaceMaterialMap *_m_mm,
      bool has_face_color_map);
 
  // List of lights used in the scene
  std::vector< osg::ref_ptr< osg::Light > > lights;
 
protected:
  MixedMeshesVector v_mixed_meshes;
 
  std::vector< std::string > v_meshes_names;
  std::vector< PMapsContainer * > v_properties_maps;
  std::vector< osg::Group * > v_draggers1;
  std::vector< osg::Group * > v_draggers2;
  std::vector< bool > v_meshIsSelected;
  std::vector< osg::Geode * > v_geodes;
 
  std::vector< std::vector< osg::ref_ptr< osg::Geometry > > > v_geometries,
      v_geometriesL, v_geometriesP, v_geometries_edges, v_geometries_vertices, v_geometries_normals, v_geometries_custom_vectors;
  std::vector< std::vector< osg::ref_ptr< osg::Vec3Array > > > v_vertexArrays,
      v_vertexArrays_edges, v_vertexArrays_vertices, v_vertexArrays_normals, v_vertexArrays_custom_vectors;
  std::vector< std::vector< osg::ref_ptr< osg::Vec3Array > > > v_normalsArrays,
      v_normalsArraysF, v_normalsArrays_edges, v_normalsArrays_vertices;
  std::vector< std::vector< osg::ref_ptr< osg::Vec3Array > > > v_tangentsArrays;
  std::vector< std::vector< osg::ref_ptr< osg::Vec4Array > > > v_colorsArrays,
      v_colorsArrays_edges, v_colorsArrays_vertices, v_colorsArrays_normals, v_colorsArrays_custom_vectors;
  std::vector< std::vector< osg::ref_ptr< osg::Vec2Array > > >
      v_texcoordsArrays;
 
public:
  osg::ref_ptr< osg::Group > gizmo;
  osg::ref_ptr< osg::Group > grid;
 
  osg::ref_ptr< osg::Group > hud;
  osg::ref_ptr< osgText::Text > hudText;
 
  int i_time;
  int current_i_time;
};
 
} // namespace FEVV
 
#include "Visualization/MeshLoading.inl"
#include "Visualization/SimpleViewer.inl"
 
#ifdef FEVV_USE_CGAL
#include "Visualization/SimpleViewerCGALPointSet.inl"
#endif
 
#ifdef FEVV_USE_PCL
#include "Visualization/SimpleViewerPCLPointCloud.inl"
#endif