Re: [ros-users] Shared memory image plugin

>         Shared memory transport is a common feature request. There's a
>         long discussion of the issues at
>         http://ros-users.122217.n3.nabble.com/Shared-memory-transport-using-C-in-ROS-td414682.html
>         <http://ros-users.122217.n3.nabble.com/Shared-memory-transport-using-C-in-ROS-td414682.html%20>that
>         should get you caught up.

>     This links says me "Not found"...

>         Short version:
>          * We haven't found shared memory transport of serialized data
>         to be a significant improvement versus TCP over loopback, but
>         are interested in evidence to the contrary.
>          * Storing the message objects themselves in shared memory
>         could be a win, but gets very complicated to implement.
>          * We've focused on optimizing intra-process (no-copy) message
>         passing and are developing the nodelet
>         <http://www.ros.org/wiki/nodelet> infrastructure; big point
>         clouds are the motivating use case.

>     Similarly, I don't observe a significant performance gain on my
>     laptop either. From htop output, I could make myself believe that
>     5-10% perf gain are possible, but this is clearly marginal.
>     However, it might be different with more active processes, more
>     cpus, less cpus, more/less rams, bigger use of the network stack,
>     different hardware (gumstix?), so I would tend to put this
>     image_transport_plugins in the common pool, just in case.

class ImageConverter {
    protected:

        ros::NodeHandle n_;
        image_transport::ImageTransport it_;
        sensor_msgs::CvBridge bridge_;
        image_transport::Publisher image_pub_;
        IplImage *cv_image;
        sensor_msgs::Image image;

    public:

        ImageConverter(ros::NodeHandle &n) : n_(n), it_(n_) {
            image_pub_ = it_.advertise("image_source",1);
            // cv_image = cvCreateImage(cvSize(640,480),8,1);
            // image = *(bridge_.cvToImgMsg(cv_image, "mono8"));
            // cv_image = cvCreateImage(cvSize(640,480),8,3);
            cv_image = cvCreateImage(cvSize(1500,1000),8,3);
            // cv_image = cvCreateImage(cvSize(3000,2000),8,3);
            image = *(bridge_.cvToImgMsg(cv_image, "bgr8"));
        }

        ~ImageConverter()
        {
        }

        int imageCapture()
        {

            ros::Rate loop_rate(30);
            while (ros::ok())
            {
                try
                {
                    image.header.stamp = ros::Time::now();
                    image_pub_.publish(image);
                    ROS_DEBUG("Published image at %f",image.header.stamp.toSec());
                }
                catch (sensor_msgs::CvBridgeException error)
                {
                    ROS_ERROR("error");
                }
                ros::spinOnce();
                loop_rate.sleep();
            }

            return 0;
        }

int main(int argc, char** argv)
{
    ros::init(argc, argv, "test_publisher");
    ros::NodeHandle n;
    ImageConverter ic(n);
    ic.imageCapture();
    return 0;
}

void callback(const sensor_msgs::ImageConstPtr& image)
{
    double tnow = ros::Time::now().toSec();
    double tstamp = image->header.stamp.toSec();
    if (!fp) {
        char fname[512];
        sprintf(fname,"received_%d_%s_%dx%dx%s.txt",
                getpid(),transport.c_str(),image->width,image->height,
                image->encoding.c_str());
        ROS_INFO("Saving data in %s",fname);
        fp = fopen(fname,"w");
    }
    fprintf(fp,"%d %f %f %f\n",npoints,tnow,tstamp,tnow-tstamp);
    npoints ++;

    ROS_INFO("%d: Image received at %f, delay %f",
            getpid(),tstamp,tnow-tstamp);

    if (npoints > 1000) {
        fclose(fp);
        ros::shutdown();
    }
}

  transport = std::string((argc > 1) ? argv[1] : "raw");
  image_transport::Subscriber sub = it.subscribe("image_source", 1, callback, 
          transport);
  ROS_INFO("test_receiver started");