.. _program_listing_file__tmp_ws_src_rviz_rviz_default_plugins_include_rviz_default_plugins_robot_robot_link.hpp:

Program Listing for File robot_link.hpp
=======================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_rviz_rviz_default_plugins_include_rviz_default_plugins_robot_robot_link.hpp>` (``/tmp/ws/src/rviz/rviz_default_plugins/include/rviz_default_plugins/robot/robot_link.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
    * Copyright (c) 2008, Willow Garage, Inc.
    * Copyright (c) 2018, Bosch Software Innovations GmbH.
    * 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 Willow Garage, Inc. 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.
    */
   
   #ifndef RVIZ_DEFAULT_PLUGINS__ROBOT__ROBOT_LINK_HPP_
   #define RVIZ_DEFAULT_PLUGINS__ROBOT__ROBOT_LINK_HPP_
   
   #include <map>
   #include <memory>
   #include <string>
   #include <vector>
   
   #ifndef Q_MOC_RUN
   
   #include <OgreVector3.h>
   #include <OgreQuaternion.h>
   #include <OgreAny.h>
   #include <OgreMaterial.h>
   #include <OgreSharedPtr.h>
   
   #endif
   
   #include <QObject>
   
   #include <urdf/model.h>  // can be replaced later by urdf_model/types.h
   #include <urdf_model/pose.h>
   
   #include "rviz_rendering/objects/object.hpp"
   #include "rviz_common/interaction/forwards.hpp"
   
   #include "rviz_default_plugins/robot/robot_element_base_class.hpp"
   #include "rviz_default_plugins/visibility_control.hpp"
   
   namespace Ogre
   {
   class SceneManager;
   class Entity;
   class SubEntity;
   class SceneNode;
   class Quaternion;
   class Any;
   class RibbonTrail;
   }  // namespace Ogre
   
   namespace rviz_rendering
   {
   class Shape;
   class Axes;
   }  // namespace rviz_rendering
   
   namespace rviz_common
   {
   namespace properties
   {
   class FloatProperty;
   class Property;
   class BoolProperty;
   class QuaternionProperty;
   class VectorProperty;
   }  // namespace properties
   class DisplayContext;
   }  // namespace rviz_common
   
   namespace rviz_default_plugins
   {
   namespace robot
   {
   
   class Robot;
   class RobotLinkSelectionHandler;
   class RobotJoint;
   typedef std::shared_ptr<RobotLinkSelectionHandler> RobotLinkSelectionHandlerPtr;
   
   
   class RVIZ_DEFAULT_PLUGINS_PUBLIC RobotLink : public RobotElementBaseClass
   {
     Q_OBJECT
   
   public:
     RobotLink(
       Robot * robot,
       const urdf::LinkConstSharedPtr & link,
       const std::string & parent_joint_name,
       bool visual,
       bool collision,
       bool mass,
       bool inertia);
     ~RobotLink() override;
   
     virtual void setRobotAlpha(float a);
   
     virtual void setTransforms(
       const Ogre::Vector3 & visual_position, const Ogre::Quaternion & visual_orientation,
       const Ogre::Vector3 & collision_position, const Ogre::Quaternion & collision_orientation);
   
     void setToErrorMaterial();
     void setToNormalMaterial();
   
     void setColor(float red, float green, float blue);
     void unsetColor();
   
     bool setSelectable(bool selectable);
     bool getSelectable();
   
     bool hasGeometry() const;
   
     /* If set to true, the link will only render to the depth channel
      * and be in render group 0, so it is rendered before anything else.
      * Thus, it will occlude other objects without being visible.
      */
     void setOnlyRenderDepth(bool onlyRenderDepth);
     bool getOnlyRenderDepth() const {return only_render_depth_;}
   
     // access
     const std::string & getName() const {return name_;}
     const std::string & getParentJointName() const {return parent_joint_name_;}
     const std::vector<std::string> & getChildJointNames() const {return child_joint_names_;}
     rviz_common::properties::Property * getLinkProperty() const {return robot_element_property_;}
     Ogre::SceneNode * getVisualNode() const {return visual_node_;}
     Ogre::SceneNode * getCollisionNode() const {return collision_node_;}
     Robot * getRobot() const {return robot_;}
     const std::string getGeometryErrors() const;
   
     // get the meshes vector to be used in robot_test.cpp
     std::vector<Ogre::Entity *> getVisualMeshes() {return visual_meshes_;}
     std::vector<Ogre::Entity *> getCollisionMeshes() {return collision_meshes_;}
   
   public Q_SLOTS:
     void updateVisibility();
   
   private Q_SLOTS:
     void updateAlpha();
     void updateTrail();
   
   private:
     void setProperties(const urdf::LinkConstSharedPtr & link);
     void createDescription(const urdf::LinkConstSharedPtr & link);
     void setRenderQueueGroup(Ogre::uint8 group);
     bool getEnabled() const override;
     Ogre::Entity * createEntityForGeometryElement(
       const urdf::LinkConstSharedPtr & link,
       const urdf::Geometry & geom, const urdf::Pose & origin,
       std::string material_name, Ogre::SceneNode * scene_node);
     void assignMaterialsToEntities(
       const urdf::LinkConstSharedPtr & link,
       const std::string & material_name,
       const Ogre::Entity * entity);
     Ogre::MaterialPtr getMaterialForLink(
       const urdf::LinkConstSharedPtr & link, std::string material_name = "");
     urdf::VisualSharedPtr getVisualWithMaterial(
       const urdf::LinkConstSharedPtr & link, const std::string & material_name) const;
     void loadMaterialFromTexture(
       Ogre::MaterialPtr & material_for_link, const urdf::VisualSharedPtr & visual) const;
   
     void createCollision(const urdf::LinkConstSharedPtr & link);
   
     void addError(const char * format, ...);
   
     void createVisual(const urdf::LinkConstSharedPtr & link);
     void createMass(const urdf::LinkConstSharedPtr & link);
     void createInertia(const urdf::LinkConstSharedPtr & link);
     void createSelection();
   
     template<typename T>
     void createVisualizable(
       const urdf::LinkConstSharedPtr & link,
       std::vector<Ogre::Entity *> & meshes_vector,
       const std::vector<T> & visualizables_array,
       const T & visualizable_element,
       Ogre::SceneNode * scene_node)
     {
       bool valid_visualizable_found = false;
   
       for (const auto & vector_element : visualizables_array) {
         T link_visual_element = vector_element;
         if (link_visual_element && link_visual_element->geometry) {
           Ogre::Entity * mesh = createEntityForGeometryElement(
             link, *link_visual_element->geometry, link_visual_element->origin, "", scene_node);
           if (mesh) {
             meshes_vector.push_back(mesh);
             valid_visualizable_found = true;
           }
         }
       }
   
       if (!valid_visualizable_found && visualizable_element && visualizable_element->geometry) {
         Ogre::Entity * mesh = createEntityForGeometryElement(
           link, *visualizable_element->geometry, visualizable_element->origin, "", scene_node);
         if (mesh) {
           meshes_vector.push_back(mesh);
         }
       }
     }
   
   protected:
     Ogre::SceneManager * scene_manager_;
     rviz_common::DisplayContext * context_;
   
     std::string parent_joint_name_;
     std::vector<std::string> child_joint_names_;
   
     // properties
     rviz_common::properties::Property * trail_property_;
     rviz_common::properties::FloatProperty * alpha_property_;
   
   private:
     typedef std::map<Ogre::SubEntity *, Ogre::MaterialPtr> M_SubEntityToMaterial;
     M_SubEntityToMaterial materials_;
     Ogre::MaterialPtr default_material_;
     std::string default_material_name_;
   
     std::vector<Ogre::Entity *> visual_meshes_;    
     std::vector<Ogre::Entity *> collision_meshes_;  
   
     Ogre::SceneNode * visual_node_;          
     Ogre::SceneNode * collision_node_;       
     Ogre::SceneNode * mass_node_;            
     Ogre::SceneNode * inertia_node_;         
     rviz_rendering::Shape * mass_shape_;     
     rviz_rendering::Shape * inertia_shape_;  
   
     Ogre::RibbonTrail * trail_;
   
     float material_alpha_;  
     float robot_alpha_;  
   
     bool only_render_depth_;
     bool is_selectable_;
   
     RobotLinkSelectionHandlerPtr selection_handler_;
   
     Ogre::MaterialPtr color_material_;
     bool using_color_;
   
     std::string error;
   
     friend class RobotLinkSelectionHandler;
   };
   
   }  // namespace robot
   }  // namespace rviz_default_plugins
   
   #endif  // RVIZ_DEFAULT_PLUGINS__ROBOT__ROBOT_LINK_HPP_