pose_array_plugin.cpp

Go to the documentation of this file.

 
#include <mapviz_plugins/pose_array_plugin.h>
 
// Declare plugin
#include <pluginlib/class_list_macros.h>
PLUGINLIB_EXPORT_CLASS(mapviz_plugins::PoseArrayPlugin, mapviz::MapvizPlugin)
 
namespace mapviz_plugins
{
  PoseArrayPlugin::PoseArrayPlugin() : config_widget_(new QWidget())
  {
    ui_.setupUi(config_widget_);
 
    ui_.color->setColor(Qt::green);
 
    // Set background white
    QPalette p(config_widget_->palette());
    p.setColor(QPalette::Background, Qt::white);
    config_widget_->setPalette(p);
 
    // Set status text red
    QPalette p3(ui_.status->palette());
    p3.setColor(QPalette::Text, Qt::red);
    ui_.status->setPalette(p3);
 
    QObject::connect(ui_.selecttopic, SIGNAL(clicked()), this,
                     SLOT(SelectTopic()));
    QObject::connect(ui_.topic, SIGNAL(editingFinished()), this,
                     SLOT(TopicEdited()));
    QObject::connect(ui_.positiontolerance, SIGNAL(valueChanged(double)), this,
                     SLOT(PositionToleranceChanged(double)));
    QObject::connect(ui_.drawstyle, SIGNAL(activated(QString)), this,
                     SLOT(SetDrawStyle(QString)));
    QObject::connect(ui_.static_arrow_sizes, SIGNAL(clicked(bool)),
                     this, SLOT(SetStaticArrowSizes(bool)));
    QObject::connect(ui_.arrow_size, SIGNAL(valueChanged(int)),
                     this, SLOT(SetArrowSize(int)));
    QObject::connect(ui_.color, SIGNAL(colorEdited(const QColor&)), this,
            SLOT(SetColor(const QColor&)));
  }
 
  PoseArrayPlugin::~PoseArrayPlugin()
  {
  }
 
  void PoseArrayPlugin::SelectTopic()
  {
    ros::master::TopicInfo topic =
        mapviz::SelectTopicDialog::selectTopic("geometry_msgs/PoseArray");
 
    if (!topic.name.empty())
    {
      ui_.topic->setText(QString::fromStdString(topic.name));
      TopicEdited();
    }
  }
 
  void PoseArrayPlugin::TopicEdited()
  {
    std::string topic = ui_.topic->text().trimmed().toStdString();
    if (topic != topic_)
    {
      initialized_ = false;
      ClearPoints();
      has_message_ = false;
      PrintWarning("No messages received.");
 
      pose_sub_.shutdown();
 
      topic_ = topic;
      if (!topic.empty())
      {
        pose_sub_ = node_.subscribe(topic_, 10, &PoseArrayPlugin::PoseArrayCallback, this);
 
        ROS_INFO("Subscribing to %s", topic_.c_str());
      }
    }
  }
 
  void PoseArrayPlugin::PoseArrayCallback(const geometry_msgs::PoseArrayConstPtr& msg)
  {  
    if (!has_message_)
    {
      initialized_ = true; // callback won't draw till this is true
      has_message_ = true;
    }
 
    ClearPoints();
 
    StampedPoint stamped_point;
    for (unsigned int i=0 ; i < msg->poses.size(); i++)
    {
        stamped_point.stamp = msg->header.stamp;
        stamped_point.source_frame = msg->header.frame_id;
        geometry_msgs::Pose pose = msg->poses[i];
 
        stamped_point.point = tf::Point(pose.position.x,
                                        pose.position.y,
                                        pose.position.z);
 
        stamped_point.orientation = tf::Quaternion(
                pose.orientation.x,
                pose.orientation.y,
                pose.orientation.z,
                pose.orientation.w);
 
        pushPoint( std::move( stamped_point) );
    }
  }
 
  void PoseArrayPlugin::PrintError(const std::string& message)
  {
    PrintErrorHelper(ui_.status, message);
  }
 
  void PoseArrayPlugin::PrintInfo(const std::string& message)
  {
    PrintInfoHelper(ui_.status, message);
  }
 
  void PoseArrayPlugin::PrintWarning(const std::string& message)
  {
    PrintWarningHelper(ui_.status, message);
  }
 
  QWidget* PoseArrayPlugin::GetConfigWidget(QWidget* parent)
  {
    config_widget_->setParent(parent);
 
    return config_widget_;
  }
 
  bool PoseArrayPlugin::Initialize(QGLWidget* canvas)
  {
    canvas_ = canvas;
    SetColor(ui_.color->color());
 
    return true;
  }
 
  void PoseArrayPlugin::Draw(double x, double y, double scale)
  {
    if (DrawPoints(scale))
    {
      PrintInfo("OK");
    }
  }
 
  void PoseArrayPlugin::LoadConfig(const YAML::Node& node, const std::string& path)
  {
    if (node["topic"])
    {
      std::string topic;
      node["topic"] >> topic;
      ui_.topic->setText(topic.c_str());
    }
 
    if (node["color"])
    {
      std::string color;
      node["color"] >> color;
      QColor qcolor(color.c_str());
      SetColor(qcolor);
      ui_.color->setColor(qcolor);
    }
 
    if (node["draw_style"])
    {
      std::string draw_style;
      node["draw_style"] >> draw_style;
 
      if (draw_style == "arrows")
      {
        ui_.drawstyle->setCurrentIndex(0);
        SetDrawStyle( ARROWS );
      }
      else if (draw_style == "points")
      {
        ui_.drawstyle->setCurrentIndex(1);
        SetDrawStyle( POINTS );
      }
    }
 
    if (node["position_tolerance"])
    {
      double position_tolerance;
      node["position_tolerance"] >> position_tolerance;
      ui_.positiontolerance->setValue(position_tolerance);
      PositionToleranceChanged(position_tolerance);
    }
 
    if (node["static_arrow_sizes"])
    {
      bool static_arrow_sizes = node["static_arrow_sizes"].as<bool>();
      ui_.static_arrow_sizes->setChecked(static_arrow_sizes);
      SetStaticArrowSizes(static_arrow_sizes);
    }
 
    if (node["arrow_size"])
    {
      int arrow_size = node["arrow_size"].as<int>();
      ui_.arrow_size->setValue(arrow_size);
      SetArrowSize(arrow_size);
    }
 
    TopicEdited(); // forces redraw
  }
 
  void PoseArrayPlugin::SaveConfig(YAML::Emitter& emitter, const std::string& path)
  {
    std::string topic = ui_.topic->text().toStdString();
    emitter << YAML::Key << "topic" << YAML::Value << topic;
 
    emitter << YAML::Key << "color" << YAML::Value
            << ui_.color->color().name().toStdString();
 
    std::string draw_style = ui_.drawstyle->currentText().toStdString();
    emitter << YAML::Key << "draw_style" << YAML::Value << draw_style;
 
    emitter << YAML::Key << "position_tolerance" <<
               YAML::Value << positionTolerance();
 
    emitter << YAML::Key << "static_arrow_sizes" << YAML::Value << ui_.static_arrow_sizes->isChecked();
 
    emitter << YAML::Key << "arrow_size" << YAML::Value << ui_.arrow_size->value();
  }
}