MeshVisual.hpp

Go to the documentation of this file.

/*
 *  Software License Agreement (BSD License)
 *
 *  Robot Operating System code by the University of Osnabrück
 *  Copyright (c) 2015, University of Osnabrück
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   1. Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer.
 *
 *   2. 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.
 *
 *   3. Neither the name of the copyright holder 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 HOLDER 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.
 *
 *
 *
 *  MeshVisual.hpp
 *
 *
 *  authors:
 *
 *    Sebastian Pütz <spuetz@uni-osnabrueck.de>
 *    Henning Deeken <hdeeken@uni-osnabrueck.de>
 *    Marcel Mrozinski
 *    Nils Oesting
 *    Kristin Schmidt <krschmidt@uni-osnabrueck.de>
 *    Jan Philipp Vogtherr <jvogtherr@uni-osnabrueck.de>
 */
 
#ifndef MESH_VISUAL_HPP
#define MESH_VISUAL_HPP
 
#include <mesh_msgs/MeshGeometryStamped.h>
#include <mesh_msgs/MeshGeometry.h>
#include <mesh_msgs/MeshVertexColorsStamped.h>
#include <mesh_msgs/MeshVertexColors.h>
#include <mesh_msgs/MeshVertexCostsStamped.h>
#include <mesh_msgs/MeshVertexCosts.h>
#include <mesh_msgs/MeshMaterialsStamped.h>
#include <mesh_msgs/MeshMaterials.h>
#include <mesh_msgs/MeshMaterial.h>
#include <mesh_msgs/MeshTexture.h>
 
#include <sensor_msgs/Image.h>
 
#include <rviz/display_context.h>
#include <rviz/frame_manager.h>
 
#include <OGRE/OgreSceneNode.h>
#include <OGRE/OgreSceneManager.h>
#include <OGRE/OgreManualObject.h>
#include <OGRE/OgreEntity.h>
#include <OGRE/OgreMaterialManager.h>
#include <OGRE/OgreColourValue.h>
 
#include <Types.hpp>
#include <vector>
 
namespace Ogre
{
// Forward declaration
class Vector3;
class Quaternion;
class SceneNode;
class Entity;
 
}  // End namespace Ogre
 
namespace rviz_map_plugin
{
class MeshVisual
{
public:
  MeshVisual(rviz::DisplayContext* context, size_t displayID, size_t meshID, size_t randomID);
 
  virtual ~MeshVisual();
 
  void reset();
 
  bool setGeometry(const Geometry& geometry);
 
  bool setNormals(const std::vector<Normal>& normals);
 
  bool setVertexColors(const std::vector<Color>& vertexColors);
 
  bool setVertexCosts(const std::vector<float>& vertexCosts);
 
  bool setVertexCosts(const std::vector<float>& vertexCosts, int costColorType);
 
  bool setVertexCosts(const std::vector<float>& vertexCosts, int costColorType, float minCost, float maxCost);
 
  bool setMaterials(const vector<Material>& materials, const vector<TexCoords>& texCoords);
 
  bool addTexture(Texture& texture, uint32_t textureIndex);
 
  void setFramePosition(const Ogre::Vector3& position);
 
  void setFrameOrientation(const Ogre::Quaternion& orientation);
 
  void updateMaterial(bool showFaces, Ogre::ColourValue facesColor, float facesAlpha, bool useVertexColors,
                      bool showVertexCosts, bool showTextures, bool showTexturedFacesOnly);
 
  void updateMaterial(bool showWireframe, Ogre::ColourValue wireframeColor, float wireframeAlpha, bool showFaces,
                      Ogre::ColourValue facesColor, float facesAlpha, bool useVertexColors, bool showVertexCosts,
                      bool showTextures, bool showTexturedFacesOnly, bool showNormals, Ogre::ColourValue normalsColor,
                      float normalsAlpha, float normalsScallingFactor);
 
  void updateNormals(float scallingFactor);
 
  void updateNormals(bool showNormals, Ogre::ColourValue normalsColor, float normalsAlpha);
 
  void updateNormals(bool showNormals, Ogre::ColourValue normalsColor, float normalsAlpha, float scalingFactor);
 
  void updateWireframe(bool showWireframe, Ogre::ColourValue wireframeColor, float wireframeAlpha);
 
private:
  void showWireframe(Ogre::Pass* pass, Ogre::ColourValue wireframeColor, float wireframeAlpha);
 
  void showFaces(Ogre::Pass* pass, Ogre::ColourValue facesColor, float facesAlpha, bool useVertexColors);
 
  void showNormals(Ogre::Pass* pass, Ogre::ColourValue normalsColor, float normalsAlpha);
 
  void showTextures(Ogre::Pass* pass);
 
  void enteringGeneralTriangleMesh(const Geometry& mesh);
 
  void enteringColoredTriangleMesh(const Geometry& mesh, const vector<Color>& vertexColors);
 
  void enteringTriangleMeshWithVertexCosts(const Geometry& mesh, const vector<float>& vertexCosts, int costColorType);
  void enteringTriangleMeshWithVertexCosts(const Geometry& mesh, const vector<float>& vertexCosts, int costColorType,
                                           float minCost, float maxCost);
 
  void enteringTexturedTriangleMesh(const Geometry& mesh, const vector<Material>& meshMaterials,
                                    const vector<TexCoords>& texCoords);
 
  void enteringNormals(const Geometry& mesh, const vector<Normal>& normals);
 
  Ogre::PixelFormat getOgrePixelFormatFromRosString(std::string encoding);
 
  void loadImageIntoTextureMaterial(size_t textureIndex);
 
  Ogre::ColourValue calculateColorFromCost(float cost, int costColorType);
 
  bool m_vertex_normals_enabled;
  bool m_vertex_colors_enabled;
  bool m_vertex_costs_enabled;
  bool m_materials_enabled;
  bool m_texture_coords_enabled;
  bool m_textures_enabled;
 
  Ogre::SceneNode* m_sceneNode;
 
  rviz::DisplayContext* m_displayContext;
 
  size_t m_prefix;
 
  size_t m_postfix;
 
  size_t m_random;
 
  Ogre::ManualObject* m_mesh;
 
  Ogre::ManualObject* m_normals;
 
  Ogre::ManualObject* m_vertexCostsMesh;
 
  Ogre::ManualObject* m_texturedMesh;
 
  Ogre::ManualObject* m_noTexCluMesh;
 
  // The textures for the mesh
  std::vector<Ogre::Image> m_images;
 
  // The material for the textured mesh
  Ogre::MaterialPtr m_texturedMeshMaterial;
 
  Ogre::MaterialPtr m_meshGeneralMaterial;
 
  Ogre::MaterialPtr m_meshTexturedTrianglesMaterial;
 
  Ogre::MaterialPtr m_normalMaterial;
 
  Ogre::MaterialPtr m_noTexCluMaterial;
 
  Ogre::MaterialPtr m_vertexCostMaterial;
 
  std::vector<Ogre::MaterialPtr> m_textureMaterials;
 
  float m_normalsScalingFactor;
 
  Geometry m_geometry;
 
  std::vector<Normal> m_geometryNormals;
};
}  // End namespace rviz_map_plugin
 
#endif