C++ tendrils类代码示例

 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");
  }