/home/laradmin/lar/demos/follow_pedestrian/src/follow_pedestrian.cpp

Go to the documentation of this file.

/**************************************************************************************************
 Software License Agreement (BSD License)

 Copyright (c) 2011-2013, LAR toolkit developers - University of Aveiro - http://lars.mec.ua.pt
 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 University of Aveiro 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 HOLDER 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 _FOLLOW_PEDESTRIAN_CPP_
#define _FOLLOW_PEDESTRIAN_CPP_

#include "follow_pedestrian.h"


void foveationcontrol_sweeping(void)
{
        static ros::Time tic=ros::Time::now();
        //      static int state=0;
        double x,y,z;
        pcl::PointXYZ pt;       

        if((ros::Time::now()-tic).toSec()>4.)
        {
                tic=ros::Time::now();

                x = (((double)rand())/(double)RAND_MAX);
                pt.x = x*10+15;

                y = (((double)rand())/(double)RAND_MAX);
                pt.y = y*20-10;

                z = (((double)rand())/(double)RAND_MAX);
                pt.z = z*2;

                pcl::PointCloud<pcl::PointXYZ> pc;
                pc.points.push_back(pt);
                sensor_msgs::PointCloud2 pcmsg_out;
                pcl::toROSMsg(pc, pcmsg_out);
                pcmsg_out.header.stamp = ros::Time::now();
                pcmsg_out.header.frame_id = "/atc/vehicle/rear_axis";
                p_pub_fctlr->publish(pcmsg_out);

        }
}

bool is_safe_using_lasers(void)
{
        static ros::Time tic = ros::Time::now();


        if(!FLAG_LASER_SAFE_TO_DRIVE)
                tic = ros::Time::now();

        if((ros::Time::now() - tic).toSec() > 5.5)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}

void sleepok(int t, ros::NodeHandle &nh)
{
        if (nh.ok()) sleep(t);
}

void play_sound(int sit, int mandatory, double num_h)
{
        //always 0 - 5 hipothesys
        unsigned int b_h;       

        if (mandatory<0)
        {
                status.tic_last_sound=ros::Time::now();

        }else if ((ros::Time::now()-status.tic_last_sound).toSec() >mandatory)
        {
                status.tic_last_sound=ros::Time::now();
        }
        else
        {
                return;
        }

        b_h = round((double)(a_h*(double)num_h));
        char text[1024];
        sprintf(text,"sit%d_hip%d",sit,b_h);


        std::string path= ros::package::getPath("atlas_sound_player")+ "/Recordings/GoogleLady_ros/" + text + ".wav";
        p_sc->playWave(path);
        sleepok(0.1, *p_n);

        printf("playing sound %s\n",text);
        //sleep(3);

}



void print_status(t_status* status)                                                                    
{
        printf("*****************************\n");
        switch(status->state)
        {   
                case SEARCHING:
                        printf("** Searching for new target\n");
                        break;

                case TRACKING:
                        printf("** Tracking target %d\n",status->target_id);
                        break;

                case TARGET_LOST:
                        printf("** Target lost\n");
                        break;

                case INITIALISE:
                        printf("** Initialising\n");
                        break;
                case TRACKING_NOT_SAFE:
                        printf("** Tracking_not_safe\n");
                        break;
        }   
}


bool check_safety_zone(t_targets* targets, t_safety_zone* safety_zone)                                
{
        double x,y;
        for(size_t i=0; i<targets->position.points.size(); ++i)
        {
                x=targets->position[i].x;
                y=targets->position[i].y;

                if(x<safety_zone->xmax && x>safety_zone->xmin && y<safety_zone->ymax && y>safety_zone->ymin)
                        return false;
        }

        return true;
}


void mtt_targets_cb (const mtt::TargetListPC& targetlist)
{
        pcl::PointCloud<pcl::PointXYZ> pc_local;
        pcl::fromROSMsg(targetlist.position, pc_local);

        pcl::PointCloud<pcl::PointXYZ> v_local;
        pcl::fromROSMsg(targetlist.velocity, v_local);


        tf::StampedTransform transform;
        try
        {
                p_listener->lookupTransform(targetlist.header.frame_id, "/atc/vehicle/rear_axis" , ros::Time(0), transform);
        }
        catch (tf::TransformException ex)
        {
                ROS_ERROR("Could find valid transform after waiting 3 secs\n.%s",ex.what());
        }


        // Transform pc1 to pc2 ->transform
        pcl_ros::transformPointCloud(pc_local, targets.position, transform.inverse());
        targets.position.header.frame_id = "/atc/vehicle/rear_axis";

        pcl_ros::transformPointCloud(v_local, targets.velocity, transform.inverse());
        targets.position.header.frame_id = "/atc/vehicle/rear_axis";

        targets.id.erase(targets.id.begin(), targets.id.end());
        for (size_t i=0; i<targetlist.id.size(); ++i)
        {
                targets.id.push_back(targetlist.id[i]);
        }


        //check safety zone
        FLAG_LASER_SAFE_TO_DRIVE = check_safety_zone(&targets, &safety_zone);

#if _USE_DEBUG_
        //ROS_INFO("Received mtt_targets id size=%ld pc size = %ld", targets.id.size(), pc.points.size());
#endif

}


bool search_for_new_target(t_targets* targets, t_status* status, t_search_area* area)
{
        double d;

        for(size_t i=0; i<targets->id.size(); ++i)
        {
                d=sqrt( (targets->position[i].x - area->x)*(targets->position[i].x - area->x)+
                                (targets->position[i].y - area->y)*(targets->position[i].y - area->y));

                if(d > area->radius)
                        continue;


                ROS_INFO("Search area x=%f y=%f rad=%f \nFound target %d x=%f y=%f inside search zone %f",area->x, area->y, area->radius, targets->id[i],targets->position[i].x, targets->position[i].y, d);
                status->target_id = targets->id[i];
                status->current_x = targets->position[i].x;
                status->current_y = targets->position[i].y;
                status->current_z = targets->position[i].z;

                return true;
        }

        return false;
}

bool get_new_target_information(t_targets *targets, t_status* status)
{
        for(size_t i=0; i<targets->id.size(); ++i)
        {
                if(status->target_id!= targets->id[i])
                        continue;

                status->target_id = targets->id[i];
                status->current_x = targets->position[i].x;
                status->current_y = targets->position[i].y;
                status->current_z = targets->position[i].z;

                status->current_q = tf::createQuaternionMsgFromYaw(atan2(targets->velocity[i].y, targets->velocity[i].x)); 

                return true;
        }

        return false;
}

void init_search_area(t_search_area* area)
{
        //Set the search area
        area->x = _SEARCH_X_;   
        area->y = _SEARCH_Y_;   
        area->radius = _SEARCH_RADIUS_;
}

void foveationcontrol(t_status* status)
{
        pcl::PointCloud<pcl::PointXYZ> pc;
        pcl::PointXYZ pt;       
        pt.x = status->current_x; pt.y = status->current_y;     pt.z = 0.8;
        pc.points.push_back(pt);
        sensor_msgs::PointCloud2 pcmsg_out;
        pcl::toROSMsg(pc, pcmsg_out);
        pcmsg_out.header.stamp = ros::Time::now();
        pcmsg_out.header.frame_id = "/atc/vehicle/rear_axis";
        p_pub_fctlr->publish(pcmsg_out);
}

void foveationcontrol_home(void)
{
        pcl::PointCloud<pcl::PointXYZ> pc;
        pcl::PointXYZ pt;       
        pt.x = 10; pt.y = 0;    pt.z = 5;
        pc.points.push_back(pt);
        sensor_msgs::PointCloud2 pcmsg_out;
        pcl::toROSMsg(pc, pcmsg_out);
        pcmsg_out.header.stamp = ros::Time::now();
        pcmsg_out.header.frame_id = "/atc/vehicle/rear_axis";
        p_pub_fctlr->publish(pcmsg_out);
}


void set_high_command_msg_direction_speed(atlascar_base::AtlascarCommand& msg, double dir, double speed)
{
        msg.steering_wheel = dir;
        msg.speed = speed;
}

void set_high_command_msg_lights(atlascar_base::AtlascarCommand& msg, bool high, bool medium, bool left, bool right, bool warning)
{
        msg.lights_high = high;
        msg.lights_medium = medium;
        msg.lights_left = left;
        msg.lights_right = right;
        msg.lights_warning = warning;
}

int main(int argc, char **argv)
{

        ros::init(argc, argv, "planar_pc_generator_node");
        ros::NodeHandle n("~");
        tf::TransformListener listener(n,ros::Duration(10));
        p_listener=&listener;
        p_n=&n;

        //create a sound_play client
        sound_play::SoundClient sc;
        p_sc = &sc;

        //create the fctlr publisher
        ros::Publisher pub_fctlr = n.advertise<sensor_msgs::PointCloud2>("/target", 1);
        p_pub_fctlr = &pub_fctlr;

        //ros::Publisher pedestrian_marker_pub = n.advertise<visualization_msgs::Marker>("/pedestrian_marker", 1);

        //set the search area
        init_search_area(&search_area);

        //set the safety zone
        safety_zone.xmax = _SAFE_ZONE_X_MAX_;
        safety_zone.xmin = _SAFE_ZONE_X_MIN_;
        safety_zone.ymax = _SAFE_ZONE_Y_MAX_;
        safety_zone.ymin = _SAFE_ZONE_Y_MIN_;

        //declare the subscribers
        ros::Subscriber sub_targets = n.subscribe("/mtt/targets", 1, mtt_targets_cb);

        //declare the publishers
        ros::Publisher vis_pub = n.advertise<visualization_msgs::MarkerArray>( "/follow_pedestrian_markers", 0 );
        command_pub = n.advertise<atlascar_base::AtlascarCommand>("/atc/base/command", 10);

        command_msg.direct_control=0;
        command_msg.ignition=1;
        command_msg.lifetime=2;
        command_msg.priority=1;
        command_msg.auto_direction=1;
        command_msg.auto_ignition=1;
        command_msg.auto_throttle=1;
        command_msg.auto_brake=1;
        command_msg.auto_clutch=1;

        //STATUS msgs
        status.state=INITIALISE;
        status.tic_last_sound = ros::Time::now();

        //wait a bit before starting
        ros::Rate initial_sleep(0.2);
        initial_sleep.sleep();

        ros::Rate loop_rate(10);
        while (n.ok())
        {
                ros::spinOnce();

                //Run the state machine
                state_machine();

                //   ___________________________________
                //   |                                 |
                //   |        DRAW_IN_RVIZ             |
                //   |_________________________________| 
                visualization_msgs::MarkerArray marker_msg;
                add_to_viz_markers_vec(&marker_msg.markers);
                vis_pub.publish(marker_msg);


                loop_rate.sleep();      
        }
}
#endif

---

follow_pedestrian
Author(s): Miguel Oliveira, Jorge Almeida
autogenerated on Wed Jul 23 04:34:25 2014