offscreenRenderer.cpp

Go to the documentation of this file.

#include <rve_transformer/frame_manager.h>
#include <rve_common_transformers/urdf.h>
#include <rve_common_transformers/camera_following_camera.h>

#include <rve_msgs/make_vector3.h>
#include <rve_msgs/make_quaternion.h>

#include "offscreenRenderer.h"

static const unsigned IMAGE_WIDTH = 640;
static const unsigned IMAGE_HEIGHT = 480;
static const unsigned IMAGE_QUEUE = 50;

namespace offscreen_renderer
{
  OffscreenRenderer::OffscreenRenderer(const rve_render_client::ClientContextPtr& p_context,
                                       const std::string &p_camera_topic,
                                       ros::NodeHandle &p_nh)
    : context_(p_context)
      , scene_(rve_render_client::createScene(context_))
      , camera_(rve_render_client::createCamera(scene_.get()))
      , transformer_manager_(new rve_transformer::TransformerManager(p_nh))
      , tf_subs_(p_nh.subscribe("/tf",IMAGE_QUEUE,&OffscreenRenderer::tfSubscriberCb,this))
      , render_offscreen_(new rve_render_client::RenderOffscreen(IMAGE_WIDTH,IMAGE_HEIGHT))
  {
    // create the texture that will be used for the rendering
    render_offscreen_->create(context_.get());

    // dummy position, will be reset later according to camera_info
    camera_->setPosition(rve_msgs::makeVector3(-10, 0, 0));
    camera_->lookAt(rve_msgs::makeVector3(0, 0, 0));
    render_offscreen_->attachCamera(camera_);

    transformer_manager_->getFrameManager()->setFixedFrame("base_footprint");

    rve_common_transformers::URDFPtr urdf = transformer_manager_->createTransformer<rve_common_transformers::URDF>();
    urdf->attachToScene(scene_.get());
    urdf->attachToContext(context_.get());

    rve_common_transformers::CameraFollowingCameraPtr cam =
      transformer_manager_->createTransformer<rve_common_transformers::CameraFollowingCamera>();
    cam->setCamera(camera_);

    cam->setSubscription("camera_info", p_camera_topic);
  }

  // request a render each time we get a tf message
  void OffscreenRenderer::tfSubscriberCb(const boost::shared_ptr<tf::tfMessage const>& p_msg)
  {
    ROS_DEBUG("received tf; updating the render");
    try
    {
      transformer_manager_->update();
      render_offscreen_->requestRender();
    }
    catch (std::exception& e)
    {
      ROS_ERROR("%s", e.what());
    }
  }
} // namespace offscreen_renderer