

map_cluster_cluster_vec WCP2dToy::Clustering_isolated(WCP::PR3DClusterSelection &live_clusters, WCP::map_pr3dcluster_double &cluster_length_map)
{

    TPCParams &mp = Singleton<TPCParams>::Instance();
    double pitch_u = mp.get_pitch_u();
    double pitch_v = mp.get_pitch_v();
    double pitch_w = mp.get_pitch_w();
    double angle_u = mp.get_angle_u();
    double angle_v = mp.get_angle_v();
    double angle_w = mp.get_angle_w();
    double time_slice_width = mp.get_ts_width();
    TVector3 drift_dir(1, 0, 0);

    int range_cut = 150;
    int length_cut = 20 * units::cm;

    PR3DClusterSelection big_clusters;
    PR3DClusterSelection small_clusters;

    // hack
    map_cluster_cluster_vec ret;
    std::vector<std::pair<PR3DCluster *, double>> ret1;
    for (size_t i = 0; i != live_clusters.size(); i++)
    {
        ret[live_clusters.at(i)] = ret1;
    }
    return ret;
    //

    for (size_t i = 0; i != live_clusters.size(); i++)
    {
        std::vector<int> ranges = live_clusters.at(i)->get_uvwt_range();
        int max = 0;
        for (int j = 0; j != 4; j++)
        {
            if (ranges.at(j) > max)
                max = ranges.at(j);
        }
        if (max < range_cut && cluster_length_map[live_clusters.at(i)] < length_cut)
        {
            small_clusters.push_back(live_clusters.at(i));
        }
        else
        {
            if (cluster_length_map[live_clusters.at(i)] < 60 * units::cm)
            {
                if (JudgeSeparateDec_1(live_clusters.at(i), drift_dir, cluster_length_map[live_clusters.at(i)], time_slice_width))
                {
                    std::vector<PR3DCluster *> sep_clusters = Separate_2(live_clusters.at(i), 2.5 * units::cm);
                    int max = 0;
                    double max_length = 0;
                    for (auto it = sep_clusters.begin(); it != sep_clusters.end(); it++)
                    {
                        std::vector<int> ranges = (*it)->get_uvwt_range();
                        double length_1 = sqrt(2. / 3. * (pow(pitch_u * ranges.at(0), 2) + pow(pitch_v * ranges.at(1), 2) + pow(pitch_w * ranges.at(2), 2)) + pow(time_slice_width * ranges.at(3), 2));
                        for (int j = 0; j != 4; j++)
                        {
                            if (ranges.at(j) > max)
                            {
                                max = ranges.at(j);
                                max_length = length_1;
                            }
                        }
                        if (max >= range_cut || max_length >= length_cut)
                            break;
                    }

                    for (size_t j = 0; j != sep_clusters.size(); j++)
                    {
                        delete sep_clusters.at(j);
                    }

                    if (max < range_cut && max_length < length_cut)
                    {
                        small_clusters.push_back(live_clusters.at(i));
                    }
                    else
                    {
                        big_clusters.push_back(live_clusters.at(i));
                    }
                }
                else
                {
                    big_clusters.push_back(live_clusters.at(i));
                }
            }
            else
            {
                big_clusters.push_back(live_clusters.at(i));
            }
        }
    }

    std::set<std::pair<PR3DCluster *, PR3DCluster *>> to_be_merged_pairs;

    // clustering small with big ones ...
    double small_big_dis_cut = 80 * units::cm;
    std::set<PR3DCluster *> used_small_clusters;
    for (auto it = small_clusters.begin(); it != small_clusters.end(); it++)
    {
        PR3DCluster *curr_cluster = (*it);
        curr_cluster->Create_point_cloud();
        ToyPointCloud *cloud1 = curr_cluster->get_point_cloud();
        double min_dis = 1e9;
        PR3DCluster *min_dis_cluster = 0;

        for (auto it1 = big_clusters.begin(); it1 != big_clusters.end(); it1++)
        {
            PR3DCluster *big_cluster = (*it1);
            big_cluster->Create_point_cloud();
            ToyPointCloud *cloud2 = big_cluster->get_point_cloud();
            std::tuple<int, int, double> results = cloud2->get_closest_points(cloud1);
            double dis = std::get<2>(results);
            if (dis < min_dis)
            {
                min_dis = dis;
                min_dis_cluster = big_cluster;
            }
        }
        if (min_dis < small_big_dis_cut)
        {
            to_be_merged_pairs.insert(std::make_pair(min_dis_cluster, curr_cluster));
            used_small_clusters.insert(curr_cluster);
        }
    }

    // small distance ...
    double small_small_dis_cut = 5 * units::cm;
    for (size_t i = 0; i != small_clusters.size(); i++)
    {
        PR3DCluster *cluster1 = small_clusters.at(i);
        ToyPointCloud *cloud1 = cluster1->get_point_cloud();
        for (size_t j = i + 1; j != small_clusters.size(); j++)
        {
            PR3DCluster *cluster2 = small_clusters.at(j);
            ToyPointCloud *cloud2 = cluster2->get_point_cloud();
            std::tuple<int, int, double> results = cloud2->get_closest_points(cloud1);
            double dis = std::get<2>(results);
            if (dis < small_small_dis_cut)
            {
                if (used_small_clusters.find(cluster1) != used_small_clusters.end() && used_small_clusters.find(cluster2) == used_small_clusters.end() ||
                    used_small_clusters.find(cluster2) != used_small_clusters.end() && used_small_clusters.find(cluster1) == used_small_clusters.end())
                {
                    to_be_merged_pairs.insert(std::make_pair(cluster1, cluster2));
                    used_small_clusters.insert(cluster1);
                    used_small_clusters.insert(cluster2);
                }
            }
        }
    }

    std::vector<PR3DCluster *> remaining_small_clusters;
    for (auto it = small_clusters.begin(); it != small_clusters.end(); it++)
    {
        PR3DCluster *curr_cluster = (*it);
        if (used_small_clusters.find(curr_cluster) == used_small_clusters.end())
            remaining_small_clusters.push_back(curr_cluster);
    }

    // clustering small with small ones ...
    small_small_dis_cut = 50 * units::cm;
    for (size_t i = 0; i != remaining_small_clusters.size(); i++)
    {
        PR3DCluster *cluster1 = remaining_small_clusters.at(i);
        ToyPointCloud *cloud1 = cluster1->get_point_cloud();
        for (size_t j = i + 1; j != remaining_small_clusters.size(); j++)
        {
            PR3DCluster *cluster2 = remaining_small_clusters.at(j);
            ToyPointCloud *cloud2 = cluster2->get_point_cloud();
            std::tuple<int, int, double> results = cloud2->get_closest_points(cloud1);
            double dis = std::get<2>(results);
            if (dis < small_small_dis_cut)
            {
                to_be_merged_pairs.insert(std::make_pair(cluster1, cluster2));
            }
        }
    }

    // clustering big ones ...
    std::set<PR3DCluster *> used_big_clusters;
    double big_dis_cut = 3 * units::cm;
    double big_dis_range_cut = 16 * units::cm;
    for (size_t i = 0; i != big_clusters.size(); i++)
    {
        PR3DCluster *cluster1 = big_clusters.at(i);
        cluster1->Create_point_cloud();
        for (size_t j = i + 1; j != big_clusters.size(); j++)
        {
            PR3DCluster *cluster2 = big_clusters.at(j);
            cluster2->Create_point_cloud();
            ToyPointCloud *cloud1, *cloud2;
            double pca_ratio, small_cluster_length;
            if (cluster_length_map[cluster1] > cluster_length_map[cluster2])
            {
                cloud1 = cluster1->get_point_cloud();
                cloud2 = cluster2->get_point_cloud();
                if (used_big_clusters.find(cluster2) != used_big_clusters.end())
                    continue;
                cluster2->Calc_PCA();
                pca_ratio = cluster2->get_PCA_value(1) / cluster2->get_PCA_value(0);
                small_cluster_length = cluster_length_map[cluster2];
            }
            else
            {
                cloud1 = cluster2->get_point_cloud();
                cloud2 = cluster1->get_point_cloud();
                if (used_big_clusters.find(cluster1) != used_big_clusters.end())
                    continue;
                cluster1->Calc_PCA();
                pca_ratio = cluster1->get_PCA_value(1) / cluster1->get_PCA_value(0);
                small_cluster_length = cluster_length_map[cluster1];
            }
            // std::cout << cluster1->get_num_mcells() << " " << cluster2->get_num_mcells() << " " << cluster1->get_point_cloud() << " " << cluster2->get_point_cloud() << std::endl;

            std::tuple<int, int, double> results = cloud2->get_closest_points(cloud1);
            double min_dis = std::get<2>(results);
            if (min_dis < big_dis_cut)
            {
                bool flag_merge = true;

                int num_outside_points = 0;
                /* int num_close_points = 0; */
                const int N = cloud2->get_num_points();
                WCP::WCPointCloud<double> &cloud = cloud2->get_cloud();
                for (int k = 0; k != N; k++)
                {
                    Point test_p1(cloud.pts[k].x, cloud.pts[k].y, cloud.pts[k].z);
                    double close_dis = cloud1->get_closest_dis(test_p1);
                    if (close_dis > big_dis_range_cut)
                    {
                        num_outside_points++;
                        if (num_outside_points > 400)
                            break;
                    }
                    /* if (close_dis <= big_dis_cut) */
                    /*   num_close_points ++;  */
                }

                // std::cout << num_outside_points << " " << N << " " << num_close_points << std::endl;

                if (num_outside_points > 0.125 * N || num_outside_points > 400)
                    flag_merge = false;

                //	std::cout << pca_ratio << " " << small_cluster_length/units::cm << std::endl;
                if (flag_merge && small_cluster_length > 60 * units::cm && pca_ratio < 0.0015)
                    flag_merge = false;

                if (flag_merge)
                {

                    to_be_merged_pairs.insert(std::make_pair(cluster1, cluster2));
                    if (cluster_length_map[cluster1] < cluster_length_map[cluster2])
                    {
                        used_big_clusters.insert(cluster1);
                    }
                    else
                    {
                        used_big_clusters.insert(cluster2);
                    }
                }
            }
        }
    }

    // merge clusters
    std::vector<std::set<PR3DCluster *>> merge_clusters;
    std::set<PR3DCluster *> used_clusters;

    for (auto it = to_be_merged_pairs.begin(); it != to_be_merged_pairs.end(); it++)
    {
        PR3DCluster *cluster1 = (*it).first;
        PR3DCluster *cluster2 = (*it).second;
        /* std::cout << cluster1 << " " << cluster2 << " " << cluster1->get_cluster_id() << " " << cluster2->get_cluster_id() << " " << cluster_length_map[cluster1]/units::cm << " " << cluster_length_map[cluster2]/units::cm << std::endl; */

        used_clusters.insert(cluster1);
        used_clusters.insert(cluster2);

        bool flag_new = true;
        std::vector<std::set<PR3DCluster *>> temp_set;
        for (auto it1 = merge_clusters.begin(); it1 != merge_clusters.end(); it1++)
        {
            std::set<PR3DCluster *> &clusters = (*it1);
            if (clusters.find(cluster1) != clusters.end() ||
                clusters.find(cluster2) != clusters.end())
            {
                clusters.insert(cluster1);
                clusters.insert(cluster2);
                flag_new = false;
                temp_set.push_back(clusters);
                // break;
            }
        }
        if (flag_new)
        {
            std::set<PR3DCluster *> clusters;
            clusters.insert(cluster1);
            clusters.insert(cluster2);
            merge_clusters.push_back(clusters);
        }
        if (temp_set.size() > 1)
        {
            // merge them further ...
            std::set<PR3DCluster *> clusters;
            for (size_t i = 0; i != temp_set.size(); i++)
            {
                for (auto it1 = temp_set.at(i).begin(); it1 != temp_set.at(i).end(); it1++)
                {
                    clusters.insert(*it1);
                }
                merge_clusters.erase(find(merge_clusters.begin(), merge_clusters.end(), temp_set.at(i)));
            }
            merge_clusters.push_back(clusters);
        }
    }

    for (auto it = live_clusters.begin(); it != live_clusters.end(); it++)
    {
        PR3DCluster *cluster = *it;
        if (used_clusters.find(cluster) == used_clusters.end())
        {
            std::set<PR3DCluster *> temp_clusters;
            temp_clusters.insert(cluster);
            merge_clusters.push_back(temp_clusters);
        }
    }

    // new stuff ...
    map_cluster_cluster_vec results;
    for (auto it = merge_clusters.begin(); it != merge_clusters.end(); it++)
    {
        std::set<PR3DCluster *> &cluster_set = (*it);
        double max_length = 0;
        PR3DCluster *max_cluster;
        for (auto it1 = cluster_set.begin(); it1 != cluster_set.end(); it1++)
        {
            PR3DCluster *temp_cluster = (*it1);
            if (cluster_length_map[temp_cluster] > max_length)
            {
                max_length = cluster_length_map[temp_cluster];
                max_cluster = temp_cluster;
            }
        }
        std::vector<std::pair<PR3DCluster *, double>> temp;
        results[max_cluster] = temp;
        max_cluster->Create_point_cloud();
        ToyPointCloud *cloud1 = max_cluster->get_point_cloud();

        for (auto it1 = cluster_set.begin(); it1 != cluster_set.end(); it1++)
        {
            PR3DCluster *temp_cluster = (*it1);
            if (temp_cluster == max_cluster)
                continue;

            temp_cluster->Create_point_cloud();
            ToyPointCloud *cloud2 = temp_cluster->get_point_cloud();
            std::tuple<int, int, double> Tresults = cloud2->get_closest_points(cloud1);
            double dis = std::get<2>(Tresults);
            results[max_cluster].push_back(std::make_pair(temp_cluster, dis));
        }
    }

    return results;

    /* PR3DClusterSelection big_clusters; */
    /* PR3DClusterSelection small_clusters; */
    /* for (size_t i=0;i!=live_clusters.size();i++){ */
    /*   std::vector<int> ranges = live_clusters.at(i)->get_uvwt_range(); */
    /*   int max = 0; */
    /*   for (int j=0;j!=4;j++){ */
    /*     if (ranges.at(j)>max) */
    /* 	max =ranges.at(j); */
    /*   } */
    /*   //    std::cout << ranges.at(0) << " " << ranges.at(1) << " " << ranges.at(2) << " " << ranges.at(3) << " " << max << std::endl; */
    /*   if (max < 80){ */
    /*     small_clusters.push_back(live_clusters.at(i)); */
    /*   }else{ */
    /*     big_clusters.push_back(live_clusters.at(i)); */
    /*   } */
    /* } */

    /* std::map<PR3DCluster*,std::vector<std::pair<PR3DCluster*,double>>> results; */
    /* // Now for each small clusters, find the big clusters with the shortest distance and connect them */
    /* for (auto it = small_clusters.begin(); it!= small_clusters.end(); it++){ */
    /*   PR3DCluster* curr_cluster = (*it); */
    /*   curr_cluster->Create_point_cloud(); */
    /*   ToyPointCloud *cloud1 = curr_cluster->get_point_cloud(); */
    /*   double min_dis = 1e9; PR3DCluster* min_dis_cluster = 0; */
    /*   for (auto it1 = big_clusters.begin(); it1!=big_clusters.end(); it1++){ */
    /*     PR3DCluster* big_cluster = (*it1); */
    /*     big_cluster->Create_point_cloud(); */
    /*     ToyPointCloud *cloud2 = big_cluster->get_point_cloud(); */

    /*     std::tuple<int,int,double> results =  cloud2->get_closest_points(cloud1); */
    /*     double dis = std::get<2>(results); */

    /*     if (dis < min_dis){ */
    /* 	min_dis = dis; */
    /* 	min_dis_cluster = big_cluster; */
    /*     } */
    /*   } */
    /*   if (min_dis < 0.8*units::m){ */
    /*     if (results.find(min_dis_cluster)==results.end()){ */
    /* 	std::vector<std::pair<PR3DCluster*,double>> temp; */
    /* 	temp.push_back(std::make_pair(curr_cluster,min_dis)); */
    /* 	results[min_dis_cluster]=temp; */
    /*     }else{ */
    /* 	results[min_dis_cluster].push_back(std::make_pair(curr_cluster,min_dis)); */
    /*     } */
    /*   }else{ */
    /*     big_clusters.push_back(curr_cluster); */
    /*     std::vector<std::pair<PR3DCluster*,double>> temp; */
    /*     results[curr_cluster] = temp; */
    /*   } */
    /* } */

    /* return results; */
}
