C++ cluster函数代码示例

/**
 * @function process
 */
void process( pcl::PointCloud<pcl::PointXYZRGBA>::Ptr _cloud ) {

  // Segment
  TabletopSegmentor<pcl::PointXYZRGBA> tts;

  tts.processCloud( _cloud );
  mTableCoeffs = tts.getTableCoeffs();
  int n = tts.getNumClusters();

  // Set segmented variables
  gClusters.resize(0);
  for( int i = 0; i < n; ++i ) {
      pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cluster( new pcl::PointCloud<pcl::PointXYZRGBA>() );
      gClusters.push_back( cluster );
  }

  gColors.resize(n);
  


  for( int i = 0; i < n; ++i ) {
     
      pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cluster( new pcl::PointCloud<pcl::PointXYZRGBA>() );
      *cluster = tts.getCluster(i);
      gClusters[i] = cluster;
      Eigen::Vector3i def;
      def(0) = rand() % 255; def(1) = rand() % 255; def(2) = rand() % 255;  
      gColors[i]<< (double) def(0) / 255.0, (double) def(1) / 255.0, (double) def(2) / 255.0;
  }
  
}

int main(int argc, char* argv[])
{
    if (argc < 6) {
        std::cout << "Usage: " << argv[0] << " in out-image out-csv threshold [sort-mode]\n";
        std::cout << "  sort-mode: sort-by-color, sort-by-count\n";
        return 0;
    }

    cv::Mat Z;
    std::string f = argv[1];
    if (fs::is_directory(f)) {
        Z = loadThumbnails(f);
    } else if (fs::path(f).extension() == ".png" || fs::path(f).extension() == ".jpg") {
        Z = loadImage(f);
    } else {
        Z = loadVideo(f);
    }

    std::cout << "Clustering...\n";
    std::vector<Cluster> centers;
    if (std::string(argv[4]).find(".") == std::string::npos) {
        cluster(Z, (int)atoi(argv[4]), centers);
    } else {
        cluster(Z, (float)atof(argv[4]), centers);
    }

    std::string sort_mode = argc >= 6 ? argv[5] : "sort-by-count";
    if (sort_mode == "sort-by-color") {
        sortCentersByColor(centers);
    } else {
        sortCentersByCount(centers);
    }
    exportCenters(centers, argv[2], argv[3]);
}

TEST(podio, equality) {
  auto cluster = ExampleCluster();
  auto rel = ExampleWithOneRelation();
  rel.cluster(cluster);
  auto returned_cluster = rel.cluster();
  EXPECT_EQ(cluster,returned_cluster);
  EXPECT_EQ(returned_cluster,cluster);
}

char * ban_it(char *nick, char *user, char *host, char *ip)
{
static char banstr[BIG_BUFFER_SIZE/4+1];
char *t = user;
char *t1 = user;
char *tmp;
	
	*banstr = 0;
	while (strlen(t1)>9)
		t1++;
	t1 = clear_server_flags(t1);
	switch (defban) 
	{
		case 7:
			if (ip)
			{
				snprintf(banstr, sizeof banstr, "*!*@%s",
					cluster(ip));
				break;
			}
		case 2: /* Better 	*/
			snprintf(banstr, sizeof banstr, "*!*%[email protected]%s", t1, 
				cluster(host));
			break;
		case 3: /* Host 	*/
			snprintf(banstr, sizeof banstr, "*!*@%s", host);
			break;
		case 4: /* Domain	*/
			tmp = strrchr(host, '.');
			if (tmp) {
				snprintf(banstr, sizeof banstr, "*!*@*%s",
					tmp);
			} else {
				snprintf(banstr, sizeof banstr, "*!*@%s", 
					host);
			}
			break;	
		case 5: /* User		*/
			snprintf(banstr, sizeof banstr, "*!%[email protected]%s", t, 
				cluster(host));
			break;
		case 6: /* Screw 	*/
			snprintf(banstr, sizeof banstr, "*!*%[email protected]%s", t1, host);
			screw(banstr);
			break;
		case 1:	/* Normal 	*/
		default:
			snprintf(banstr, sizeof banstr, "%s!*%[email protected]%s", nick, t1,
				host);
			break;
	}
	return banstr;
}

bool Package::Depend(const Package& p) const
{
  bool depends(false);

  std::string cluster(fs::basename(fs::path(m_Package->first).leaf()));
  if(cluster.empty())
  {
    cluster = fs::basename(fs::absolute(m_Package->first).filename());
  }

  std::cout << "subgraph cluster_"
            << cluster
            << "{" << std::endl
            << "label=" << cluster
            << ';' << std::endl;

  for(std::set<Object>::const_iterator it = m_Package->second.object.begin();
      it != m_Package->second.object.end(); ++it)
  {
    std::cout << '"' << fs::basename(fs::path(it->Name()).leaf()) << "\";" << std::endl;
  }

  for(std::set<Package>::const_iterator it = m_Package->second.package.begin();
      it != m_Package->second.package.end(); ++it)
  {
    it->Depend(p);
  }

  std::cout << "}" << std::endl;

  return depends;
}

std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr> MovingObjectsIdentificator::extractClusters() {
    if(verbose) std::cout << "Extracting clusters ... ";
    pcl::search::KdTree<pcl::PointXYZ>::Ptr kdTree (new pcl::search::KdTree<pcl::PointXYZ>);
    kdTree->setInputCloud(workingCloud);

    std::vector<pcl::PointIndices> indices;
    pcl::EuclideanClusterExtraction<pcl::PointXYZ> ece;
    ece.setClusterTolerance(clusterTolerance);
    ece.setMinClusterSize(minClusterSize);
    ece.setSearchMethod(kdTree);
    ece.setInputCloud(workingCloud);
    ece.extract(indices);

    std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr > clusters;
    for(std::vector<pcl::PointIndices>::iterator it = indices.begin(); it != indices.end(); it++) {
        pcl::PointCloud<pcl::PointXYZ>::Ptr cluster(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::ExtractIndices<pcl::PointXYZ> extract;
        extract.setInputCloud(workingCloud);

        pcl::PointIndices::Ptr pi(new pcl::PointIndices);
        pi->indices=it->indices;
        extract.setIndices(pi);
        extract.setNegative(false);
        extract.filter(*cluster);
        clusters.push_back(cluster);
    }

    if(verbose) std::cout << "done!" << std::endl;

    return clusters;
}

void findDoorCentroids(const cloud_t::Ptr &cloud, const std::vector<pcl::PointIndices> &indices, std::vector<point_t> &centroids) 
{
    // X-coord width in meters
    const float min_width = .8;
    const float max_width = .96;

    // Loop through clusters
    for (std::vector<pcl::PointIndices>::const_iterator it = indices.begin(); it != indices.end(); ++it) {

        // Create cluster from indices
        cloud_t::Ptr cluster(new cloud_t(*cloud, (*it).indices));        

        // Second check: door width
        point_t min;
        point_t max;
        pcl::getMinMax3D(*cluster, min, max);
        float door_width = sqrt(pow(max.x-min.x, 2.) + pow(max.y-min.y, 2.));
        //std::cout << door_width << std::endl;
        if ((door_width > min_width) && (door_width < max_width)) {
            // Return door centroid
            Eigen::Matrix<float, 4, 1> centroid;    
            pcl::compute3DCentroid(*cluster, centroid);
            centroids.push_back(point_t(centroid(0), centroid(1), centroid(2)));
            std::cout << "Found door with centroid at: " << centroid(0) << ", " << centroid(1) << ", " << centroid(2) << std::endl;
        }   
    }
}

void segment_region_growing(pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud, int index, pcl::PointCloud<pcl::PointXYZRGBA>::Ptr output_cloud) {

    pcl::search::Search<pcl::PointXYZRGBA>::Ptr tree = boost::shared_ptr< pcl::search::Search<pcl::PointXYZRGBA> > (new pcl::search::KdTree<pcl::PointXYZRGBA>);

    pcl::PointCloud <pcl::Normal>::Ptr normals (new pcl::PointCloud <pcl::Normal>);
    pcl::NormalEstimation<pcl::PointXYZRGBA, pcl::Normal> normal_estimator;
    normal_estimator.setSearchMethod (tree);
    normal_estimator.setInputCloud (cloud);
    normal_estimator.setKSearch (50);
    normal_estimator.compute (*normals);

    pcl::IndicesPtr indices (new std::vector <int>);
    pcl::PassThrough<pcl::PointXYZRGBA> pass;
    pass.setInputCloud (cloud);
    pass.setFilterFieldName ("z");  // Filter the huge quantity of points at the origin that mean nothing
    pass.setFilterLimits (-0.01, 0.01);

    // pass.setFilterFieldName ("y");
    // pass.setFilterLimits (-0.1, 0.1);
    // pass.setFilterFieldName ("x");
    // pass.setFilterLimits (-0.1, 0.1);

    pass.setFilterLimitsNegative(true);
    pass.filter (*indices);

    pcl::PointCloud <pcl::PointXYZRGBA>::Ptr temp_visualization (new pcl::PointCloud <pcl::PointXYZRGBA>);
    pcl::PointIndices filter_pts;

    pcl::PointIndices::Ptr cluster_ptr(new pcl::PointIndices());
    cluster_ptr->indices = *indices;

    extract_indices(cloud, temp_visualization, *cluster_ptr);

    pcl::RegionGrowing<pcl::PointXYZRGBA, pcl::Normal> reg;
    reg.setMinClusterSize (10);
    reg.setMaxClusterSize (100000);
    reg.setSearchMethod (tree);
    reg.setNumberOfNeighbours (30);
    reg.setIndices(indices);
    reg.setInputCloud (cloud);

    reg.setInputNormals (normals);
    // reg.setSmoothnessThreshold (3.0 / 180.0 * M_PI);
    reg.setSmoothnessThreshold (15.0 / 180.0 * M_PI);  // More relaxed angle constraints
    reg.setCurvatureThreshold (1.0);

    // std::vector <pcl::PointIndices> clusters;
    // reg.extract (clusters);

    /*
    pcl::PointCloud <pcl::PointXYZRGB>::Ptr colored_cloud = reg.getColoredCloud();
    pcl::PointCloud <pcl::PointXYZRGBA>::Ptr colored_cloud_rgba(new pcl::PointCloud <pcl::PointXYZRGBA>);
    pcl::copyPointCloud(*colored_cloud, *colored_cloud_rgba);
    visualize(colored_cloud_rgba, "colored segmentation");
    */

    pcl::PointIndices::Ptr cluster(new pcl::PointIndices());
    reg.getSegmentFromPoint(index, *cluster);
    extract_indices(cloud, output_cloud, *cluster);
}

void CAttributeDlg::DoCheckSyntax()
{
    m_view.SyntaxChecking();
    CString ecl;
    m_view.GetText(ecl);
    CString cluster(GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_CLUSTER));
    CString module(m_attribute->GetModuleQualifiedLabel());
    CString attribute(m_attribute->GetLabel());

    if (CComPtr<IEclCC> eclcc = CreateIEclCC())
    {
        if (!DoSave(false))
            return;
    }
    if (m_attribute->GetType() == CreateIAttributeECLType())
    {
        clib::thread run(__FUNCTION__, boost::bind(&EclCheckSyntax, this, ecl, cluster, module, attribute, _T(""), _T(""), false, false));
    }
    else
    {
        IAttributeVector attrs;
        Dali::CEclExceptionVector errors;
        m_attribute->PreProcess(PREPROCESS_SYNTAXCHECK, ecl, attrs, errors);
        SendMessage(CWM_SUBMITDONE, Dali::WUActionCheck, (LPARAM)&errors);
    }
}

void 
darts :: hwloc :: AbstractMachine :: discoverTopologyWithLLC(void)
{
    unsigned nbSockets = hwloc_get_nbobjs_by_type(_topology,HWLOC_OBJ_SOCKET);
    hwloc_obj_t o = hwloc_get_obj_by_type(_topology,HWLOC_OBJ_SOCKET,0);

    hwloc_obj_t obj;
    for (obj = o->first_child;
            obj && obj->type != HWLOC_OBJ_CACHE;
            obj = obj->first_child)
        ;

    _nbClusters = nbSockets;
    if (obj) {
        int n = hwloc_get_nbobjs_inside_cpuset_by_type(_topology,obj->cpuset,HWLOC_OBJ_PU);
        _nbClusters = _nbTotalUnits / n; // XXX assumes homogeneous distribution of PUs
    }
    _clusterMap = new Cluster[_nbClusters];

    // TODO Refactor this code and the next function's code into a single one 
    for (o = obj; o; o = o->next_cousin)  {
        int           nUnits = hwloc_get_nbobjs_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU);
        Unit *units  = new Unit[nUnits];
        for (int i = 0; i < nUnits; ++i) {
            hwloc_obj_t t = hwloc_get_obj_inside_cpuset_by_type(_topology,o->cpuset,HWLOC_OBJ_PU,i);
            Unit hwu(o->logical_index,t->logical_index,t->os_index);
            units[i] = hwu; // simple shallow copy
        }
        Cluster cluster(o->logical_index,o->logical_index,nUnits,units);
        _clusterMap[o->logical_index] = cluster; // simple shallow copy
    }
}

  bool try_initialize_more (Ekiga::ServiceCore& core,
			    int* /*argc*/,
			    char** /*argv*/[])
  {
    boost::shared_ptr<Ekiga::PresenceCore> presence_core = core.get<Ekiga::PresenceCore> ("presence-core");
    boost::shared_ptr<Ekiga::CallCore> call_core = core.get<Ekiga::CallCore> ("call-core");
    boost::shared_ptr<Ekiga::PersonalDetails> details = core.get<Ekiga::PersonalDetails> ("personal-details");

    if (presence_core && call_core && details) {

      boost::shared_ptr<Avahi::PresencePublisher> publisher (new Avahi::PresencePublisher (core, *details, *call_core));
      if (core.add (publisher)) {

	presence_core->add_presence_publisher (publisher);
	result = true;
      }

      boost::shared_ptr<Avahi::Cluster> cluster (new Avahi::Cluster (core));
      if (core.add (cluster)) {

	presence_core->add_cluster (cluster);
	result = true;
      }
    }

    return result;
  }

  void build(const std::string& ip_prefix, int num_nodes) {
    test_utils::CassClusterPtr cluster(cass_cluster_new());
    test_utils::initialize_contact_points(cluster.get(), ip_prefix, num_nodes, 0);
    cass_cluster_set_load_balance_round_robin(cluster.get());
    cass_cluster_set_token_aware_routing(cluster.get(), cass_false);

    test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));

    for (int i = 0; i < num_nodes; ++i) {
      test_utils::CassStatementPtr statement(
            cass_statement_new("SELECT tokens, data_center FROM system.local", 0));
      test_utils::CassFuturePtr future(cass_session_execute(session.get(), statement.get()));
      test_utils::wait_and_check_error(future.get());
      test_utils::CassResultPtr result(cass_future_get_result(future.get()));
      const CassRow* row = cass_result_first_row(result.get());
      const CassValue* data_center = cass_row_get_column_by_name(row, "data_center");
      const CassValue* token_set = cass_row_get_column_by_name(row, "tokens");

      CassString str;
      cass_value_get_string(data_center, &str.data, &str.length);
      std::string dc(str.data, str.length);

      std::string ip = cass::get_host_from_future(future.get());
      test_utils::CassIteratorPtr iterator(cass_iterator_from_collection(token_set));
      while (cass_iterator_next(iterator.get())) {
        cass_value_get_string(cass_iterator_get_value(iterator.get()), &str.data, &str.length);
        std::string token(str.data, str.length);
        tokens[boost::lexical_cast<int64_t>(token)] = Host(ip, dc);
      }
    }
  }

int main()
{
	//CREATE GRAPH FROM A SORTED EDGE LIST FILE
	createGraph();
	
	int i=0, flg=0;
	for(i=1;i<NO_OF_ENTRIES;++i)
	{
		if(list[i]->w>list[i+1]->w)
		{
			printf("\n%d) %d %d %d\n", i, list[i]->s, list[i]->d, list[i]->w);
			flg++;
		}
	}
	if(flg==0)
	{
		printf("\nArray is sorted. Now to apply clustering...");
		getch();
	}
	else
		return -1;
	i=cluster(4);
	printf("\nMaximum spacing=%d. (At edge no.=%d)",  list[i]->w, i);
	return 0;
}

template <typename PointT> void
pcl::people::HeadBasedSubclustering<PointT>::mergeClustersCloseInFloorCoordinates (std::vector<pcl::people::PersonCluster<PointT> >& input_clusters,
    std::vector<pcl::people::PersonCluster<PointT> >& output_clusters)
{
  float min_distance_between_cluster_centers = 0.4;                   // meters
  float normalize_factor = std::pow(sqrt_ground_coeffs_, 2);          // sqrt_ground_coeffs ^ 2 (precomputed for speed)
  Eigen::Vector3f head_ground_coeffs = ground_coeffs_.head(3);        // ground plane normal (precomputed for speed)
  std::vector <std::vector<int> > connected_clusters;
  connected_clusters.resize(input_clusters.size());
  std::vector<bool> used_clusters;          // 0 in correspondence of clusters remained to process, 1 for already used clusters
  used_clusters.resize(input_clusters.size());
  for(size_t i = 0; i < input_clusters.size(); i++)             // for every cluster
  {
    Eigen::Vector3f theoretical_center = input_clusters[i].getTCenter();
    float t = theoretical_center.dot(head_ground_coeffs) / normalize_factor;    // height from the ground
    Eigen::Vector3f current_cluster_center_projection = theoretical_center - head_ground_coeffs * t;    // projection of the point on the groundplane
    for(size_t j = i+1; j < input_clusters.size(); j++)         // for every remaining cluster
    {
      theoretical_center = input_clusters[j].getTCenter();
      float t = theoretical_center.dot(head_ground_coeffs) / normalize_factor;    // height from the ground
      Eigen::Vector3f new_cluster_center_projection = theoretical_center - head_ground_coeffs * t;      // projection of the point on the groundplane
      if (((new_cluster_center_projection - current_cluster_center_projection).norm()) < min_distance_between_cluster_centers)
      {
        connected_clusters[i].push_back(j);
      }
    }
  }

  for(size_t i = 0; i < connected_clusters.size(); i++)   // for every cluster
  {
    if (!used_clusters[i])                                      // if this cluster has not been used yet
    {
      used_clusters[i] = true;
      if (connected_clusters[i].empty())                        // no other clusters to merge
      {
        output_clusters.push_back(input_clusters[i]);
      }
      else
      {
        // Copy cluster points into new cluster:
        pcl::PointIndices point_indices;
        point_indices = input_clusters[i].getIndices();
        for(const int &cluster : connected_clusters[i])
        {
          if (!used_clusters[cluster])         // if this cluster has not been used yet
          {
            used_clusters[cluster] = true;
            for(std::vector<int>::const_iterator points_iterator = input_clusters[cluster].getIndices().indices.begin();
                points_iterator != input_clusters[cluster].getIndices().indices.end(); points_iterator++)
            {
              point_indices.indices.push_back(*points_iterator);
            }
          }
        }
        pcl::people::PersonCluster<PointT> cluster(cloud_, point_indices, ground_coeffs_, sqrt_ground_coeffs_, head_centroid_, vertical_);
        output_clusters.push_back(cluster);
      }
    }
  }
    }

vector<Detection> NonMaximumSuppression::eliminateRedundantDetections(vector<Detection> candidates) const {
	if (overlapThreshold == 1.0) // with this threshold, there would be an endless loop - this check assumes distinct bounding boxes
		return candidates;
	sortByScore(candidates);
	vector<vector<Detection>> clusters = cluster(candidates);
	return getMaxima(clusters);
}