int
 configure(tendrils& params, tendrils& inputs, tendrils& outputs)
 {
   format_ = params.at("format");
   input_ = inputs.at("input");
   output_ = outputs.at("output");
 }

 static void
 declare_params(tendrils& params)
 {
   object_recognition_core::db::bases::declare_params_impl(params);
   params.declare(&Detector::threshold_, "threshold", "Matching threshold, as a percentage", 90.0f);
   params.declare(&Detector::visualize_, "visualize", "If True, visualize the output.", false);
 }

 static void
 declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
 {
   inputs.declare(&MatToPointCloudXYZRGBOrganized::points3d, "points", "The width by height by 3 channels (x, y and z)").required(true);
   inputs.declare(&MatToPointCloudXYZRGBOrganized::image, "image", "The rgb image.").required(true);
   outputs.declare(&MatToPointCloudXYZRGBOrganized::cloud_out, "point_cloud", "The XYZRGB organized point cloud");
 }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
      inputs.declare(&DepthCleaner::image_in_, "image", "The depth map").required(true);

      outputs.declare(&DepthCleaner::image_out_, "image", "The cleaned up depth image");
    }

 static void
 declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
 {
   inputs.declare(&C::in1, "image1");
   inputs.declare(&C::in2, "image2");
   outputs.declare(&C::out, "out");
 }

 static void
 declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
 {
   inputs.declare(&C::in_image, "image", "The input image, used as the base to draw on.");
   inputs.declare(&C::in_kpts, "keypoints", "The keypoints to draw.");
   outputs.declare(&C::out_image, "image", "The output image.");
 }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
      inputs.declare(&ClusterDrawer::clusters2d_, "clusters2d", "For each table, a vector of 2d clusters.");
      inputs.declare(&ClusterDrawer::image_, "image", "The image to draw on.").required(true);

      outputs.declare(&ClusterDrawer::image_clusters_, "image", "The depth image with the convex hulls for the planes.");
    }

 static void
 declare_params(tendrils& p)
 {
   p.declare(&C::n_iters, "n_iters", "number of ransac iterations", 100);
   p.declare(&C::reprojection_error, "reprojection_error", "error threshold", 8);
   p.declare(&C::min_inliers, "min_inliers", "minimum number of inliers", 25);
   p.declare(&C::inlier_thresh, "inlier_thresh", "The inlier threshold of pose found.", 30);
 }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
      inputs.declare(&ObjectRecognizer::clusters_, "clusters3d", "The object clusters.").required(true);
      inputs.declare(&ObjectRecognizer::table_coefficients_, "table_coefficients", "The coefficients of planar surfaces.").required(true);

      outputs.declare(&ObjectRecognizer::pose_results_, "pose_results", "The results of object recognition");
    }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
      inputs.declare(&Detector::color_, "image", "An rgb full frame image.");
      inputs.declare(&Detector::depth_, "depth", "The 16bit depth image.");

      outputs.declare(&Detector::pose_results_, "pose_results", "The results of object recognition");
    }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
      inputs.declare(&PlaneDrawer::image_, "image", "The current gray frame.").required(true);
      inputs.declare(&PlaneDrawer::planes_, "planes", "The different found planes (a,b,c,d) of equation ax+by+cz+d=0.");
      inputs.declare(&PlaneDrawer::masks_, "masks", "The masks for each plane.");

      outputs.declare(&PlaneDrawer::image_clusters_, "image", "The depth image with the convex hulls for the planes.");
    }

    static void
    declare_params(tendrils& params)
    {
      params.declare(&MModTrainer::thresh_learn,"thresh_learn","The threshold"
                                              "for learning a new template",0.0); //Zero thresh_learn => learn every view
      params.declare(&MModTrainer::object_id,"object_id",
                                             "The object id, to learn.")
                                             .required(true);

    }

  static void declare_io(const tendrils& params, tendrils& inputs,
                         tendrils& outputs) {
    inputs.declare(&ClusterConverter::clusters3d_, "clusters3d",
                   "The clusters on top of the table.").required(true);
    inputs.declare(&ClusterConverter::image_message_,
                   "image_message", "the image message to get the header").required(true);

    outputs.declare<sensor_msgs::PointCloud2ConstPtr>(
      "cluster_pc", "The PointCloud2 message of the top cluster");
  }

    static void
    declare_io(const tendrils& p, tendrils& i, tendrils& o)
    {
        i.declare<std::vector<ObjectId> >("ids", "The matching object ids");

        i.declare(&MModTester::image_, "image", "An image. BGR image of type CV_8UC3").required(true);
        i.declare(&MModTester::depth_, "depth", "Depth image of type CV_16UC1").required(true);
        //      i.declare<cv::Mat> ("mask", "Object mask of type CV_8UC1 or CV_8UC3").required(false);
        o.declare(&MModTester::debug_image_, "debug_image", "Debug image.");
    }

  static void declare_io(const tendrils& params, tendrils& inputs,
                         tendrils& outputs) {
    inputs.declare(&TableVisualizationMsgAssembler::clusters3d_, "clusters3d",
                   "The clusters on top of the table.").required(true);
    inputs.declare(&TableVisualizationMsgAssembler::image_message_,
                   "image_message", "the image message to get the header").required(true);

    outputs.declare<visualization_msgs::MarkerArrayConstPtr>(
      "marker_array_clusters", "The markers of the clusters");
  }

 static void
 declare_io(const tendrils& params, tendrils& in, tendrils& out)
 {
   in.declare(&StereoCalibration::image_, "image", "An image to base the size of of.").required(true);
   in.declare(&StereoCalibration::object_pts_, "points_object", "The ideal object points.").required(true);
   in.declare(&StereoCalibration::pts_left_, "points_left", "The observed 2d points in the left camera.").required(
       true);
   in.declare(&StereoCalibration::pts_right_, "points_right", "The observed 2d points in the right camera.").required(
       true);
 }

 int process(const tendrils& in, const tendrils& out)
 {
     for (tendrils::const_iterator iter = in.begin(), end = in.end(); iter!=end; ++iter)
     {
         std::cout << iter->second->tick << " >>?>> " << tick << "\n";
         if (iter->second->tick != tick)
             abort();
     }
     ++tick;
     return ecto::OK;
 }

    static void
    declare_io(const tendrils& params, tendrils& inputs, tendrils& outputs)
    {
    inputs.declare(&Trainer::json_db_, "json_db", "The DB parameters", "{}").required(
        true);
    inputs.declare(&Trainer::object_id_, "object_id",
        "The object id, to associate this model with.").required(true);

      outputs.declare(&Trainer::detector_, "detector", "The LINE-MOD detector");
      outputs.declare(&Trainer::Rs_, "Rs", "The matching rotations of the templates");
      outputs.declare(&Trainer::Ts_, "Ts", "The matching translations of the templates.");
    }

    static void
    declare_io(const tendrils& params, tendrils& i, tendrils& o)
    {
      //inputs coming off of the kinect.
      i.declare(&C::depth_, "depth", "The depth stream.").required(true);
      i.declare(&C::image_, "image", "The image stream.").required(true);
      i.declare(&C::focal_length_image_, "focal_length_image", "The focal length of the image stream.").required(true);
      i.declare(&C::focal_length_depth_, "focal_length_depth", "The focal length of the depth stream.").required(true);
      i.declare(&C::baseline_, "baseline", "The base line of the openni camera.").required(true);

      o.declare(&C::cam, "camera", "A pinhole camera model to convert.");
    }

	/*! @brief declare parameters used by the detector
	 *
	 * This method defines the mapping between the python members loaded
	 * from the config file, and the members declared in this class. This
	 * is called once at initialization, and again in instances of
	 * dynamic reconfiguration
	 *
	 * @param params the parameters
	 */
	static void declare_params(tendrils& params)
	{
		params.declare(&PartsBasedDetectorCell::visualize_, "visualize",
				"Visualize results", false);
		params.declare(&PartsBasedDetectorCell::remove_planes_, "remove_planes",
				"The cell should remove planes from the scene before the cluster extraction", false);
		params.declare(&PartsBasedDetectorCell::model_file_, "model_file",
				"The path to the model file").required(true);
		params.declare(&PartsBasedDetectorCell::max_overlap_, "max_overlap",
				"The maximum overlap allowed between object detections", 0.1);
		params.declare(&PartsBasedDetectorCell::object_db_, "db",
				"The object db.", ObjectDb());
	}