Subscribe to two image_raws with one function

edit

I think I originally took part of the code from stereo_image_proc. I guess your two webcams are not synchronized, so the following code uses approximate sync. If they are synchronized you can use exact sync in the same way.

These are your includes:

#include <sensor_msgs/Image.h>
#include <image_transport/subscriber_filter.h>
#include <message_filters/sync_policies/approximate_time.h>

And don't forget to add the corresponding dependencies in your manifest.xml/package.xml!

Subscribe to the right topics and register what callback function to call, this could go into your main function:

ros::NodeHandle nh;
image_transport::SubscriberFilter left_sub, right_sub;
image_transport::ImageTransport it(nh);
left_sub.subscribe(it, "left_topic", 1, "raw");
right_sub.subscribe(it, "right_topic", 1, "raw");

typedef message_filters::sync_policies::ApproximateTime<sensor_msgs::Image, sensor_msgs::Image> ApproximatePolicy;
typedef message_filters::Synchronizer<ApproximatePolicy> ApproximateSync;

boost::shared_ptr<ApproximateSync> approximate_sync;

approximate_sync.reset(new ApproximateSync(ApproximatePolicy(queue_size),left_sub,right_sub));
approximate_sync->registerCallback(boost::bind(callback, _1, _2));

ros::spin();

Define your callback function:

void callback(const sensor_msgs::ImageConstPtr& l_image_msg, 
              const sensor_msgs::ImageConstPtr& r_image_msg){
    ROS_INFO("Callback reached! :-)");
}

Probably I forgot some stuff so I will try to update my answer!

Good luck!

I would suggest you create two callbacks. Each callback calls your original callback, but with an argument, which stream to process.

For example:

void callback1(image_raw foo)
{
    originalCallback(foo, 1);
}

void callback2(image_raw foo)
{
    originalCallback(foo, 2);
}

void originalCallback(image_raw bar, int callerId)
{
    if(callerId == 1)
    {}
    else
    {}
}

Another possible solution could be looking at the connection header of the image_raw message.