gazebo_ros_projector.h

Go to the documentation of this file.

/*
 * Desc: A dynamic controller plugin that controls texture projection.
 * Author: Jared Duke
 * Date: 17 June 2010
 * SVN: $Id$
 */
#ifndef GAZEBO_ROS_PROJECTOR_HH
#define GAZEBO_ROS_PROJECTOR_HH

// Custom Callback Queue
#include <ros/callback_queue.h>
#include <ros/subscribe_options.h>

#include <ros/ros.h>
#include "boost/thread/mutex.hpp"

#include <gazebo/Controller.hh>
#include <gazebo/Param.hh>
#include <gazebo/Body.hh>
#include <gazebo/Model.hh>

#include <std_msgs/String.h>
#include <std_msgs/Int32.h>

#include <OgrePrerequisites.h>
#include <OgreTexture.h>
#include <OgreFrameListener.h>

namespace Ogre
{
        class PlaneBoundedVolumeListSceneQuery;
        class Frustum;
        class Pass;
  class SceneNode;
}

namespace gazebo
{

        class Geom;
        

class GazeboRosProjector : public Controller
{
  public: GazeboRosProjector(Entity *parent);

  public: virtual ~GazeboRosProjector();

  protected: virtual void LoadChild(XMLConfigNode *node);

  protected: virtual void InitChild();

  protected: virtual void UpdateChild();

  protected: virtual void FiniChild();

  private: void LoadImage(const std_msgs::String::ConstPtr& imageMsg);

  private: void ToggleProjector(const std_msgs::Int32::ConstPtr& projectorMsg); 

  private: Ogre::Root *getRootP();
        
  private: Model *myParent;
        //private: Entity *myParent;    

  private: Body *myBody;
        
  private: ros::NodeHandle* rosnode_;
  private: ros::Subscriber imageSubscriber_;
  private: ros::Subscriber projectorSubscriber_;        

  private: boost::mutex lock;

  private: ParamT<std::string> *textureTopicNameP;
  private: ParamT<std::string> *projectorTopicNameP;
  private: ParamT<std::string> *bodyNameP;
  private: ParamT<std::string> *textureNameP;
  private: ParamT<std::string> *filterTextureNameP;
  private: ParamT<double> *fovP;
  private: ParamT<double> *nearClipDistP;
  private: ParamT<double> *farClipDistP;

  private: std::string textureTopicName;

  private: std::string projectorTopicName;

        // \brief Projector parameters
  private: std::string bodyName;
  private: std::string textureName;
  private: std::string filterTextureName;               
  private: double fov;
  private: double nearClipDist;
  private: double farClipDist;
        
  private: ParamT<std::string> *robotNamespaceP;
  private: std::string robotNamespace;

  // Custom Callback Queue
  private: ros::CallbackQueue queue_;
  private: void QueueThread();
  private: boost::thread callback_queue_thread_;

  private: std::string filterNodeName;

  private: 
          class Projector : public Ogre::FrameListener
                {

                  public: Projector();
      public: virtual ~Projector();

                        public: void init( Ogre::SceneNode *sceneNodePtr = NULL,
                                           Ogre::String textureName = "stereo_projection_pattern_alpha.png",
                                           Ogre::String filterTextureName = "stereo_projection_pattern_filter.png",                                        
                                           double nearDist = .5,
                                           double farDist = 10,
                                           double fov = 0.785398163,
                         std::string filterNodeName = "FilterNode" );

                  public: virtual bool frameStarted(const Ogre::FrameEvent &evt);
      public: virtual bool frameEnded(const Ogre::FrameEvent &evt);
                  public: virtual bool frameRenderingQueued(const Ogre::FrameEvent &evt);

                public: void setEnabled( bool enabled );
                public: void setUsingShaders( bool usingShaders );                      
                public: void setSceneNode( Ogre::SceneNode *sceneNodePtr );
                public: void setTextureName( const Ogre::String& textureName );
                public: void setFilterTextureName( const Ogre::String& textureName );                   
                public: void setFrustumClipDistance( double nearDist, double farDist );
                public: void setFrustumFOV( double fovInRadians );
                                           
                private: void addProjectorPassToVisibleMaterials();
                private: void addProjectorPassToAllMaterials();
                private: void addProjectorPassToMaterials(std::list<std::string>& matList);
                private: void addProjectorPassToMaterial(std::string matName);
                private: void removeProjectorPassFromMaterials();                       
                private: void removeProjectorPassFromMaterial(std::string matName);

                private: Ogre::SceneManager* getSceneMgrP();
                        
      private: bool isEnabled;
                private: bool isInit;
                private: bool isUsingShaders;

                private: Ogre::Frustum *projectorFrustum;
                        private: Ogre::Frustum *projectorFilterFrustum;
                private: Ogre::PlaneBoundedVolumeListSceneQuery *projectorQuery;
                private: Ogre::SceneNode *projectorNode;
      private: Ogre::SceneNode *projectorFilterNode;

                  private: Ogre::String projectedTextureName;
                private: Ogre::String projectedFilterTextureName;                       

                private: std::map<std::string,Ogre::Pass*> projectorTargets;
                        
      private: std::string filterNodeName;
    };

  private: Projector projector_;

};



}
#endif

---

gazebo_plugins
Author(s): Sachin Chitta, Stu Glaser, John Hsu
autogenerated on Fri Jan 11 10:09:24 2013