Robotics StackExchange | Archived questions

error in rosmake tf_workshop

i try to learning Handling ROS Tutorial course . when i run this command i have error :

rosmake tf_workshop

error :

 /home/zakizadeh/catkin_ws2/src/tf_workshop/src/fdisplay.cpp: In member function ‘void Transforms::DrawFn(int, char*, geometry_msgs::Vector3Stamped, int)’:
  /home/zakizadeh/catkin_ws2/src/tf_workshop/src/fdisplay.cpp:62:9: error: ‘visualization_msgs::Marker’ has no member named ‘set_points_size’
    marker.set_points_size(2);

my obj_tracker file :

    #include <stdio.h>
#include <ros/ros.h>
#include <cstdlib>
#include <visualization_msgs/Marker.h>
#include <geometry_msgs/PoseStamped.h>
#include <geometry_msgs/Quaternion.h>
#include <geometry_msgs/Vector3.h>
#include <math.h>
#include <tf/transform_listener.h>
#include <tf/transform_broadcaster.h>
#include <sensor_msgs/PointCloud2.h>


#define pi 3.14159265

class Ktracker{

public:
    Ktracker();
    ros::Subscriber trkmarker_sub, pose_sub;
    ros::Publisher objectpc_pub;

    void trackCallback(const visualization_msgs::Marker&);
    void poseCallback(const geometry_msgs::PoseStamped&);

    tf::TransformListener listener;
    tf::StampedTransform transform;
    tf::TransformBroadcaster br;
    tf::Quaternion qtf;

private:
    sensor_msgs::PointCloud objectpc;


};

Ktracker::Ktracker(){

    ros::NodeHandle n;
    objectpc_pub=n.advertise<sensor_msgs::PointCloud>("objpc",1000);
}


void Ktracker::trackCallback(const visualization_msgs::Marker &msg){


    objectpc.set_points_size(msg.get_points_size());

    int i;
    for (i=0;i<(int) msg.get_points_size();i++){
        objectpc.points[i].x=msg.points[i].x;
        objectpc.points[i].y=msg.points[i].y;
        objectpc.points[i].z=msg.points[i].z;
    }

    ros::Time now = ros::Time::now();
    transform.setOrigin(tf::Vector3(msg.pose.position.x,msg.pose.position.y,msg.pose.position.z));
    tf::quaternionMsgToTF(msg.pose.orientation,qtf);
    transform.setRotation(qtf);
    br.sendTransform(tf::StampedTransform(transform, msg.header.stamp, "/openni_rgb_frame","/object_frame"));
    objectpc.header.frame_id="/object_frame";

    try
    {
// Enter the correct transformation to track the object 


        //now=ros::Time::now();
        listener.waitForTransform("/object_frame", "/end_effector",msg.header.stamp, ros::Duration(0.2));
        listener.lookupTransform("/object_frame", "/end_effector",msg.header.stamp, transform);
        listener.transformPointCloud("/end_effector",objectpc,objectpc);
        objectpc.header.frame_id="/end_effector";
        objectpc_pub.publish(objectpc);

    }
    catch (tf::TransformException ex)
    {
        ROS_WARN("TF Exception: %s", ex.what());
    }
}


void Ktracker::poseCallback(const geometry_msgs::PoseStamped &msg){
    objectpc_pub.publish(objectpc);
}

int main(int argc, char **argv)
{
    ros::init(argc, argv, "armtrack");
    Ktracker ktracker;
    ros::Rate loop_rate(20);
    visualization_msgs::Marker bluem;
    ros::NodeHandle n;
    ktracker.trkmarker_sub=n.subscribe("markers_out", 1000, &Ktracker::trackCallback,&ktracker);
    ktracker.pose_sub=n.subscribe("armpose",1000, &Ktracker::poseCallback,&ktracker);

    ros::spin();

}

my fdisplay.cpp :

#include <ros/ros.h>
#include <tf/transform_broadcaster.h>
#include <tf/transform_listener.h>
#include <geometry_msgs/WrenchStamped.h>
#include <geometry_msgs/Vector3Stamped.h>
#include <visualization_msgs/Marker.h>

class Transforms{
public:
    Transforms();
    void f1Callback(const geometry_msgs::WrenchStamped&);
    void f2Callback(const geometry_msgs::WrenchStamped&);
    void DrawFn(int,char*,geometry_msgs::Vector3Stamped,int);

    geometry_msgs::Vector3Stamped f1ft,f2ft;
    geometry_msgs::PointStamped f1cl,f2cl;
    geometry_msgs::PointStamped start;

    ros::NodeHandle node;
    tf::TransformListener listener;
    ros::Subscriber f1_sub,f2_sub;
    ros::Publisher marker_pub;
    visualization_msgs::Marker marker;
private:

};

Transforms::Transforms(){
    marker_pub = node.advertise<visualization_msgs::Marker>("fmarker", 10);
    start.point.x=0;
    start.point.y=0;
    start.point.z=0;

}






void Transforms::DrawFn(int id,char* frame, geometry_msgs::Vector3Stamped vector,int color){
    marker.header.frame_id = frame;
    marker.header.stamp = ros::Time();
    marker.ns = "my_namespace";
    marker.id = id;
    marker.type = visualization_msgs::Marker::ARROW;
    marker.action = visualization_msgs::Marker::ADD;
    marker.pose.position.x = 0;
    marker.pose.position.y = 0;
    marker.pose.position.z = 0;
    marker.pose.orientation.x = 0.0;
    marker.pose.orientation.y = 0.0;
    marker.pose.orientation.z = 0.0;
    marker.pose.orientation.w = 1.0;
    marker.scale.x = 0.008;
    marker.scale.y = 0.02;
    marker.scale.z = 0.0;
    marker.color.a = 1.0;
    marker.color.r = 1.0;
    marker.color.g = 0.0;
    marker.color.b = 0.0;
    marker.set_points_size(2);
    marker.points[0].x=(start.point.x)/1000;
    marker.points[0].y=(start.point.y)/1000;
    marker.points[0].z=(start.point.z)/1000;
    marker.points[1].x=start.point.x/1000+vector.vector.x/100;
    marker.points[1].y=start.point.y/1000+vector.vector.y/100;
    marker.points[1].z=start.point.z/1000+vector.vector.z/100;

    marker_pub.publish(marker);

}

void Transforms::f1Callback(const geometry_msgs::WrenchStamped& msg){
    f1ft.vector=msg.wrench.force;
}


void Transforms::f2Callback(const geometry_msgs::WrenchStamped& msg){
    f2ft.vector=msg.wrench.force;
}



int main(int argc, char** argv){
    ros::init(argc, argv, "forcesdisplay");


    Transforms Trans;

    Trans.f1_sub=Trans.node.subscribe("finger1/nano17ft",1000,&Transforms::f1Callback,&Trans);
        Trans.f2_sub=Trans.node.subscribe("finger2/nano17ft",1000,&Transforms::f2Callback,&Trans);

    ros::Rate rate(10.0);
    ros::Time now;
    geometry_msgs::Vector3Stamped wvect,weight,weight1;

    tf::Vector3 weight2;
    tf::Transformer TransClass;
    tf::StampedTransform transform;
    tf::Stamped<tf::Vector3> vaux,w2;


    while (Trans.node.ok()){


        Trans.DrawFn(1,"/BHand/FingerOne/Sensor",Trans.f1ft,1);
        Trans.DrawFn(2,"/BHand/FingerTwo/Sensor",Trans.f2ft,1);




        //DRAW WEIGHT:

        //FINGER 1
        tf::vector3StampedMsgToTF(Trans.f1ft,vaux);

        try{
            now = ros::Time::now();
            vaux.frame_id_="/BHand/FingerOne/Sensor";
            vaux.stamp_=now;

            Trans.listener.waitForTransform("/BHand/FingerOne/Sensor", "/robot_base",   now, ros::Duration(3.0));
            Trans.listener.lookupTransform("/BHand/FingerOne/Sensor", "/robot_base",now/*ros::Time(0)*/, transform);
            Trans.listener.transformVector("/robot_base",vaux,w2);
            tf::vector3TFToMsg(w2,wvect.vector);

            weight=wvect;

    }
    catch (tf::TransformException ex){
            ROS_ERROR("%s",ex.what());
        }
        try{

            //FINGER 2
            tf::vector3StampedMsgToTF(Trans.f2ft,vaux);
            now = ros::Time::now();
            vaux.frame_id_="/BHand/FingerTwo/Sensor";
            vaux.stamp_=now;

            Trans.listener.waitForTransform("/BHand/FingerTwo/Sensor", "/robot_base",now, ros::Duration(3.0));
            Trans.listener.lookupTransform("/BHand/FingerTwo/Sensor", "/robot_base",now, transform);
            Trans.listener.transformVector("/robot_base",vaux,w2);
            tf::vector3TFToMsg(w2,wvect.vector);

            weight.vector.x=weight.vector.x+wvect.vector.x;
            weight.vector.y=weight.vector.y+wvect.vector.y;
            weight.vector.z=weight.vector.z+wvect.vector.z;

            Trans.DrawFn(5,"/robot_base",weight,3);
            printf("Weight:%f %f %f = %f\n",weight.vector.x,weight.vector.y,weight.vector.z,sqrt(weight.vector.x*weight.vector.x+weight.vector.y*weight.vector.y+weight.vector.z*weight.vector.z));
        }
        catch (tf::TransformException ex){
            ROS_ERROR("%s",ex.what());
        }

        ros::spinOnce();
        rate.sleep();
    }
    return 0;
};

Asked by zakizadeh on 2017-05-05 12:47:35 UTC

Comments

Answers