C++ registerStream函数代码示例

bool CvSplit_Processor::onInit()
{
	LOG(LTRACE) << "CvSplit_Processor::initialize\n";

	h_onNewImage.setup(this, &CvSplit_Processor::onNewImage);
	registerHandler("onNewImage", &h_onNewImage);

	registerStream("in_img", &in_img);

	newImage = registerEvent("newImage");

	if (props.channels < 1) {
		LOG(LERROR) << "CvSplit_Processor::number of channels must be positive\n";
		return false;
	}

	mv.resize(props.channels);
	out_img.resize(props.channels);

	for (int i = 0; i < props.channels; ++i) {
		out_img[i] = new Base::DataStreamOut<cv::Mat>;
		registerStream("out_img_"+int2str(i), out_img[i]);
	}


	return true;
}

void HomogMatrixPub::prepareInterface() {
	// Register data streams, events and event handlers HERE!
    //input streams
    registerStream("in_matrix", &in_matrix);
	registerStream("in_found", &in_found);
    registerStream("in_time_nsec_pocz", &in_time_nsec_pocz);
    registerStream("in_time_sec_pocz", &in_time_sec_pocz);

    //output streams
    registerStream("out_matrix", &out_matrix);
    registerStream("out_found", &out_found);
    registerStream("out_time_nsec_pocz", &out_time_nsec_pocz);
    registerStream("out_time_sec_pocz", &out_time_sec_pocz);
    registerStream("out_time_nsec_kon", &out_time_nsec_kon);
    registerStream("out_time_sec_kon", &out_time_sec_kon);

	// Register handlers
	h_onNewData.setup(boost::bind(&HomogMatrixPub::onNewData, this));
	registerHandler("onNewData", &h_onNewData);
	addDependency("onNewData", &in_matrix);
    addDependency("onNewData", &in_found);
    //addDependency("onNewData", &in_time_nsec_pocz);
    //addDependency("onNewData", &in_time_sec_pocz);

    //registerProperty(trigger_delay);
}

void CloudViewer::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_cloud_xyz", &in_cloud_xyz);
	registerStream("in_cloud_xyzrgb", &in_cloud_xyzrgb);
	registerStream("in_cloud_xyzsift", &in_cloud_xyzsift);
	registerStream("in_cloud_normals", &in_cloud_normals);
	registerStream("in_cloud_xyzrgb_normals", &in_cloud_xyzrgb_normals);

	// Register handlers
	registerHandler("on_cloud_xyz",
			boost::bind(&CloudViewer::on_cloud_xyz, this));
	addDependency("on_cloud_xyz", &in_cloud_xyz);

	registerHandler("on_cloud_xyzrgb",
			boost::bind(&CloudViewer::on_cloud_xyzrgb, this));
	addDependency("on_cloud_xyzrgb", &in_cloud_xyzrgb);

	registerHandler("on_cloud_xyzsift",
			boost::bind(&CloudViewer::on_cloud_xyzsift, this));
	addDependency("on_cloud_xyzsift", &in_cloud_xyzsift);

	registerHandler("on_cloud_normals",
			boost::bind(&CloudViewer::on_cloud_normals, this));
	addDependency("on_cloud_normals", &in_cloud_normals);

	registerHandler("on_spin", boost::bind(&CloudViewer::on_spin, this));
	addDependency("on_spin", NULL);

	registerHandler("on_cloud_xyzrgb_normals",
			boost::bind(&CloudViewer::on_cloud_xyzrgb_normals, this));
	addDependency("on_cloud_xyzrgb_normals", &in_cloud_xyzrgb_normals);
}

bool CameraNUI::onInit() {
    LOG(LTRACE) << "CameraNUI::initialize\n";

    // Regsiter events
    newImage = registerEvent("newImage");
    newDepthMap = registerEvent("newDepthMap");

    // Register data streams
    registerStream("out_img", &outImg);
    registerStream("out_depth_map", &outDepthMap);
//
#ifdef WITH_OPENNI
    if(lib == opencv) {
        capture.open( CV_CAP_OPENNI );
        std::cout << "Yes. We're here\n";
    } else {
#endif
        device = &freenectObj.createDevice<FreenectNUIDevice>(0);
#ifdef WITH_OPENNI
    }
#endif
    cameraFrame = Mat(Size(640,480),CV_8UC3,Scalar(0));
    depthFrame = Mat(Size(640,480),CV_16UC1);
    return true;
}

void CvWindow_Sink::prepareInterface() {
	CLOG(LTRACE) << "CvWindow_Sink::configure\n";

	h_onRefresh.setup(this, &CvWindow_Sink::onRefresh);
	registerHandler("onRefresh", &h_onRefresh);

	addDependency("onRefresh", NULL);

	Base::EventHandler2 * hand;
	for (int i = 0; i < count; ++i) {
		char id = '0' + i;
		hand = new Base::EventHandler2;
		hand->setup(boost::bind(&CvWindow_Sink::onNewImageN, this, i));
		handlers.push_back(hand);
		registerHandler(std::string("onNewImage") + id, hand);

		Base::DataStreamIn<cv::Mat, Base::DataStreamBuffer::Newest,
				Base::Synchronization::Mutex> * stream =
				new Base::DataStreamIn<cv::Mat, Base::DataStreamBuffer::Newest,
						Base::Synchronization::Mutex>;
		in_img.push_back(stream);
		registerStream(std::string("in_img") + id,
				(Base::DataStreamInterface*) (in_img[i]));
		addDependency(std::string("onNewImage") + id, stream);

		in_draw.push_back(new Base::DataStreamInPtr<Types::Drawable>);
		registerStream(std::string("in_draw") + id, in_draw[i]);

		out_point.push_back(new Base::DataStreamOut<cv::Point>);
		registerStream(std::string("out_point") + id, out_point[i]);

		// save handlers
		hand = new Base::EventHandler2;
		hand->setup(boost::bind(&CvWindow_Sink::onSaveImageN, this, i));
		handlers.push_back(hand);
		registerHandler(std::string("onSaveImage") + id, hand);
	}

	h_onSaveAllImages.setup(this, &CvWindow_Sink::onSaveAllImages);
	registerHandler("onSaveAllImages", &h_onSaveAllImages);

	// register aliases for first handler and streams
	registerHandler("onNewImage", handlers[0]);
	registerStream("in_img", in_img[0]);
	registerStream("in_draw", in_draw[0]);

	img.resize(count);
	to_draw.resize(count);

	// Split window titles.
	std::string t = title;
	boost::split(titles, t, boost::is_any_of(","));
	if ((titles.size() == 1) && (count > 1))
		titles.clear();
	for (int i = titles.size(); i < count; ++i) {
		char id = '0' + i;
		titles.push_back(std::string(title) + id);
	}
}

void SphereGenerator::prepareInterface() {
	// Register data streams, events and event handlers HERE!
registerStream("out_pcl_ptr", &out_pcl_ptr);
registerStream("out_pcl", &out_pcl);
	// Register handlers
	h_Generate.setup(boost::bind(&SphereGenerator::Generate, this));
	registerHandler("Generate", &h_Generate);

}

void CalcStatistics::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_homogMatrix", &in_homogMatrix);
	registerStream("out_homogMatrix", &out_homogMatrix);

	// Register handlers
	registerHandler("calculate", boost::bind(&CalcStatistics::calculate,this));
	addDependency("calculate", &in_homogMatrix);
}

void MLS::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_cloud_xyzrgb", &in_cloud_xyzrgb);
	registerStream("out_cloud_xyzrgb", &out_cloud_xyzrgb);

	h_compute_xyzrgb.setup(boost::bind(&MLS::compute, this));
	registerHandler("h_compute_xyzrgb", &h_compute_xyzrgb);
	addDependency("h_compute_xyzrgb", &in_cloud_xyzrgb);
}

void CvFAST::prepareInterface() {
	// Register handlers with their dependencies.
	registerHandler("onNewImage", boost::bind(&CvFAST::onNewImage, this));
	addDependency("onNewImage", &in_img);

	// Input and output data streams.
	registerStream("in_img", &in_img);
	registerStream("out_features", &out_features);
}

void CalcObjectLocation::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_homogMatrix", &in_homogMatrix);
	registerStream("out_homogMatrix", &out_homogMatrix);

	// Register handlers
	h_calculate.setup(this, &CalcObjectLocation::calculate);
	registerHandler("calculate", &h_calculate);
	addDependency("calculate", &in_homogMatrix);
}

void SIFTNOMWriter::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_som", &in_som);
	registerStream("in_cloud_xyzrgb_normals", &in_cloud_xyzrgb_normals);
	registerStream("in_cloud_xyzsift", &in_cloud_xyzsift);
	registerStream("in_mean_viewpoint_features_number", &in_mean_viewpoint_features_number);

	// Register handlers
	registerHandler("WriteNormals", boost::bind(&SIFTNOMWriter::WriteNormals, this));
}

void xyzrgb2xyzsift::prepareInterface() {
	// Register data streams, events and event handlers HERE!
	registerStream("in_cloud_xyzrgb", &in_cloud_xyzrgb);
	registerStream("out_cloud_xyzsift", &out_cloud_xyzsift);
	// Register handlers
	h_compute.setup(boost::bind(&xyzrgb2xyzsift::compute, this));
	registerHandler("compute", &h_compute);
	addDependency("compute", &in_cloud_xyzrgb);

}

void PassThrough::prepareInterface() {
	// Register data streams, events and event handlers HERE!
registerStream("in_cloud", &in_cloud);
registerStream("out_cloud", &out_cloud);
	// Register handlers
	h_filter.setup(boost::bind(&PassThrough::filter, this));
	registerHandler("filter", &h_filter);
	addDependency("filter", &in_cloud);

}

void CvAdaptiveThreshold_Processor::prepareInterface() {
	
	// Register data streams, events and event handlers HERE!
	h_onNewImage.setup(this, &CvAdaptiveThreshold_Processor::onNewImage);
	registerHandler("onNewImage", &h_onNewImage);
	addDependency("onNewImage", &in_img);

	registerStream("in_img", &in_img);
	registerStream("out_img", &out_img);
}

void CvFilter2D_Processor::prepareInterface() {
	h_onNewImage.setup(this, &CvFilter2D_Processor::onNewImage);
	registerHandler("onNewImage", &h_onNewImage);
	addDependency("onNewImage", &in_img);

	registerStream("in_img", &in_img);

	registerStream("out_img", &out_img);

}