std::string s("Hello");
std::string f;

// 前两个参数是变换的范围，第三个是变换的起始位置
// 第四个参数为lambda表达式，变换的规则
std::transform(s.begin(), s.end(), s.begin(),
  [](unsigned char c) { return std::toupper(c); });
std::cout <<"after transform, s: "<< s << std::endl;  // HELLO

std::transform( s.begin(), s.end(), std::back_inserter(f),
              [](unsigned char c) { return std::tolower(c); }  );
std::cout << "after transform, f: " << f << std::endl;  // hello

std::copy( s.begin(), s.end(), std::back_inserter(f) );
std::cout << "after copy, f: " << f << std::endl;  // helloHELLO

vector<int> v={1,2,3,4,5,6};
vector<int> s;
copy(v.begin(), v.end(), back_inserter(s) );  // s: 123456

tf2_ros::Buffer buffer_;
tf2_ros::TransformListener listener(buffer_);
buffer_.transform(in_pose, out_pose, frame, transform_duration_);

class MapServer
{
  public:
    /** Trivial constructor */
    MapServer(const std::string& fname, double res)
    {
      std::string mapfname = "";
      double origin[3];
      int negate;
      double occ_th, free_th;
      MapMode mode = TRINARY;
      std::string frame_id;
      ros::NodeHandle private_nh("~");
      private_nh.param("frame_id", frame_id, std::string("map"));
      deprecated = (res != 0);
      if (!deprecated)
      {
        // 省略读 yaml 文件的代码，其实就是把yaml里的各个参数赋值给变量
#ifdef HAVE_YAMLCPP_GT_0_5_0
        // The document loading process changed in yaml-cpp 0.5.
        YAML::Node doc = YAML::Load(fin);
#else
        YAML::Parser parser(fin);
        YAML::Node doc;
        parser.GetNextDocument(doc);
#endif
          std::string modeS = "";
          doc["mode"] >> modeS;

          if(modeS=="trinary")
            mode = TRINARY;
          else if(modeS=="scale")
            mode = SCALE;
          else if(modeS=="raw")
            mode = RAW;
      	  else mode = TRINARY;

      ROS_INFO("Loading map from image \"%s\"", mapfname.c_str());
       // 这个核心函数是最底层的，使用SDL库解析图片
      map_server::loadMapFromFile(&map_resp_,mapfname.c_str(),res,negate,occ_th,free_th, origin, mode);
      
      // To make sure get a consistent time in simulation
      ros::Time::waitForValid();

      map_resp_.map.info.map_load_time = ros::Time::now();
      map_resp_.map.header.frame_id = frame_id;
      map_resp_.map.header.stamp = ros::Time::now();
      ROS_INFO("Read a %d X %d map @ %.3lf m/cell",
               map_resp_.map.info.width,
               map_resp_.map.info.height,
               map_resp_.map.info.resolution);
      meta_data_message_ = map_resp_.map.info;

      service = n.advertiseService("static_map", &MapServer::mapCallback, this);

      metadata_pub= n.advertise<nav_msgs::MapMetaData>("map_metadata", 1, true);
      metadata_pub.publish( meta_data_message_ );

      map_pub = n.advertise<nav_msgs::OccupancyGrid>("map", 1, true);
      map_pub.publish( map_resp_.map );
    }
  private:
    ros::NodeHandle n;
    ros::Publisher map_pub;
    ros::Publisher metadata_pub;
    ros::ServiceServer service;
    bool deprecated;

    bool mapCallback(nav_msgs::GetMap::Request  &req,
                     nav_msgs::GetMap::Response &res )
    {
        // request is empty; we ignore it
        // = operator is overloaded to make deep copy (tricky!)
        res = map_resp_;
        ROS_INFO("Sending map");
        return true;
    }
    // The map data is cached here, to be sent out to service callers
    nav_msgs::MapMetaData meta_data_message_;
    nav_msgs::GetMap::Response map_resp_;
};
}

vector<std::string> params;
std::string file = "123.45.abc.0";
std::istringstream param_stream(file);
std::string param;
while(getline(param_stream, param, '.'))
{
    cout << param <<endl;
    params.push_back(param);
}

bool readCSVInput(int N, vector<double> &input_points_x, vector<double> &input_points_y, vector<double> &anchor_points_x, vector<double> &anchor_points_y)
{
    ifstream readCSV("/home/user/data.csv", ios::in);
    int lineNum = 0;
    string lineString;
    vector<vector<string>> stringArray;
    cout << endl;
    while (getline(readCSV, lineString) )
    {
        //cout << lineString << endl;
        if (lineNum > 0)
        {
            stringstream ss(lineString);
            string s;
            vector<string> oneLineStrings;
            while (getline(ss, s, ',') )
                oneLineStrings.push_back(s);
            if (oneLineStrings.size() != 5)
            {
                cout << "ERROR:oneLineStrings.size() != 5" << endl;
                return false;
            }
            else
            {
                input_points_x.push_back(std::stod(oneLineStrings[1]));
                input_points_y.push_back(std::stod(oneLineStrings[2]));
                anchor_points_x.push_back(std::stod(oneLineStrings[3]));
                anchor_points_y.push_back(std::stod(oneLineStrings[4]));
            }
        }
        lineNum++;
    }
    if (N == input_points_x.size())
    {
        return true;
    }
    else
    {
        input_points_x.clear();
        input_points_y.clear();
        anchor_points_x.clear();
        anchor_points_y.clear();
        cout << "ERROR:N == input_points_x.size()" << endl;
        return false;
    }
}