TestFilterServices.cpp

Go to the documentation of this file.

#include <ros/ros.h>

#include <opencv/cv.h>
#include <opencv/highgui.h>
#include <sensor_msgs/Image.h>
#include <cv_bridge/CvBridge.h>
#include <image_transport/image_transport.h>

//service definitions
#include <face_contour_detector/GetFilters.h>
#include <face_contour_detector/ApplyFilters.h>

#include <cstdlib>

//std
#include <sstream>

int main(int argc, char **argv)
{
    ros::init(argc, argv, "test_filter_services");
    
    if (argc < 2) {
        ROS_ERROR("there must be given a image as an argument");
    }
    
    ros::NodeHandle n;
    ros::ServiceClient client = n.serviceClient<face_contour_detector::GetFilters>("get_filters");
    face_contour_detector::GetFilters srv;
    if (client.call(srv))
    {
        std::vector<face_contour_detector::filter>::iterator filterIt;
        for (filterIt = srv.response.filters.begin(); filterIt != srv.response.filters.end(); filterIt++) {
            ROS_INFO(filterIt->name.c_str());
            std::vector<face_contour_detector::parameter>::iterator paramIt;
            for (paramIt = filterIt->parameters.begin(); paramIt != filterIt->parameters.end(); paramIt++) {
                std::stringstream s;
                s<<"-->"<<paramIt->name<<":"<<paramIt->type<<" ["<<paramIt->ruler_minimum<<", "<<paramIt->ruler_maximum<<"]";
                
                ROS_INFO(s.str().c_str());
            }
        }
    }
    else
    {
        ROS_ERROR("Failed to call service get_filters");
        return 1;
    }
    
    ROS_INFO("Sending filter request");
    
    face_contour_detector::ApplyFilters applySrv;
    cv::Mat img = cv::imread(argv[1]);
    
    try {
        sensor_msgs::CvBridge cvBridge;
        IplImage ipl = img;
        applySrv.request.input_image = *(cvBridge.cvToImgMsg(&ipl));
    } catch (sensor_msgs::CvBridgeException error) {
        ROS_ERROR("could not convert the image with the cvBridge to a sensor_msgs/Image");
        return 1;
    }
    
    //alles
    face_contour_detector::name_value_pair param;
    face_contour_detector::filter_area_setup areaSetup;
    areaSetup.area.x = 0;
    areaSetup.area.y = 0;
    areaSetup.area.width = img.cols;
    areaSetup.area.height = img.rows;
    
    face_contour_detector::filter_setup filterSetup;
    filterSetup.name = "GaussianBlur";
    areaSetup.filters.push_back(filterSetup);
    filterSetup.name = "Canny";
    areaSetup.filters.push_back(filterSetup);
    
    applySrv.request.areas.push_back(areaSetup);
    
    //oben links
    areaSetup.area.x = 0;
    areaSetup.area.y = 0;
    areaSetup.area.width = img.cols/2;
    areaSetup.area.height = img.rows/2;
    
    filterSetup.name = "GaussianBlur";
    areaSetup.filters.push_back(filterSetup);
    filterSetup.name = "Canny";
    param.name = "threshold1";
    param.type = "float";
    param.value = "1000";
    filterSetup.parameters.push_back(param);
    param.name = "threshold2";
    param.type = "float";
    param.value = "2000";
    filterSetup.parameters.push_back(param);
    areaSetup.filters.push_back(filterSetup);
    
    applySrv.request.areas.push_back(areaSetup);
    
    ros::ServiceClient applyClient = n.serviceClient<face_contour_detector::ApplyFilters>("apply_filters");
    
    if (applyClient.call(applySrv)) {
        try {
            sensor_msgs::CvBridge cvBridge;
            cv::Mat result;
            if (!cvBridge.fromImage(applySrv.response.result_image))
                throw sensor_msgs::CvBridgeException("Conversion to OpenCV image failed");
            result = cvBridge.toIpl();
            cv::imwrite("test_filter_result_image.png", result);
            
        } catch (sensor_msgs::CvBridgeException error) {
            ROS_ERROR("error converting image message");
        }
        std::vector<face_contour_detector::filter_area_result>::iterator areaIt;
        for (areaIt = applySrv.response.area_results.begin(); areaIt != applySrv.response.area_results.end(); areaIt++) {
            //
            std::stringstream s;
            s<<"area(x="<<areaIt->area.x<<", y="<<areaIt->area.y<<", width="<<areaIt->area.width<<", height="<<areaIt->area.height<<")";
            ROS_INFO(s.str().c_str());
            
            std::vector<face_contour_detector::name_value_pair>::iterator propIt;
            for (propIt = areaIt->result_properties.begin(); propIt != areaIt->result_properties.end(); propIt++) {
                std::stringstream s2;
                s2<<"--> "<<propIt->name<<" : "<<propIt->type<<" = "<<propIt->value;
                ROS_INFO(s2.str().c_str());
            }
            
        }
        ROS_INFO("success");
    } else
    {
        ROS_ERROR("Failed to call service apply_filters");
        return 1;
    }
    
    return 0;
}