Point de regroupement des nuages et l'estimation limite de la région

Point de regroupement des nuages ​​et l'estimation limite de la région

　　Point de données nuage pour certaines caractéristiques et certains clusters de division régulière, le document propose un procédé de regroupement et les caractéristiques spatiales de la fusion, et la région de détection de la limite sur la base de regroupement (d'un côté de l'article qui est méthode mentionnée), l'idée spécifique de l'algorithme est la suivante:

(1) point de prétraitement des nuages , le pompage grec, etc. sécher .

(2) ne peut être enlevé des zones divisées;

(3) Ce qui suit est la zone restante de la division de groupe, la sélection de x surface maximale comme une recherche de la face de graines a commencé , la recherche du rayon adjacent, un rayon est R , alors que le rayon R recherché à l'intérieur de n triangles, ces triangles comparatif surface moyenne pondérée mid_d seuil de différence est réglé delta_d, si la différence est inférieure à la valeur seuil la distance delta_d , puis la recherche d'être un visage triangulaire de cluster Custer intégration, sinon, pas de fusion, puis il y a une nouvelle surface d' entrée visage de semences, continuer à rechercher ce qui précède, et calcule un nouveau pas moyen pondéré mid_d . Cette itération jusqu'à ce que toute la division complète de tous les groupes.

 

schéma

(4) peut être obtenu par la troisième étape de nombreuses grappes Custers , à travers tous les groupes Custers , à condition que le seuil nombre minimum de points ou de la zone A3 , sauf une surface inférieure à A3 regroupement Custer , chaque Custer surface triangulée détection et d' intégration limite.

(5) pour détecter une limite de la quatrième étape, le traitement de dentelure, principalement le traitement de lissage limite, il y a un seuil d' intensité de lissage dis_threshold , comme une limite de la zone ; retourner les limites de la zone de données.

(Note: La troisième étape principale consiste à diviser les deux étapes, une étape Cluster Theory)

 

Une partie du code:

int Division ( 
    std :: vector <PointType> & in_points, 
    std :: vector <PCTTM_TriangleFace> & face_vect, 
    std :: vector < deux > & distance_vect, 
    std :: vector <PointType> & face_center_points2, 
    std :: vector <std: : vector < int >> & region_vector, 
     const  doubles & d_threshold, 
     const  int & num_threshold) { 

    si (in_points.size () < 3 || face_vect.size () == 0 || distance_vect.taille () == 0 )
    {
        std :: Cout ) << " in_points.size () <3 || face_vect.size () == 0 || distance_vect.size () == 0 " << std :: endl;
        retourner - 1 ; 
    } 

    Std :: vector <PointType> face_center_points;
    // std :: vector <point3f_rgba> face_center_points2;
    // 计算三角面几何中心 
    std :: vector < deux > distance_vect2;     // 剔除灰色 
    std :: vector < int > out_index (face_vect.size ());
    pour (size_t i = 0 ; i <face_vect.size (); i ++ 
    {
        PointType pt2 = calculateFaceCenter (in_points [face_vect [i] .p_index_0], in_points [face_vect [i] .p_index_1], in_points [face_vect [i] .p_index_2]); 

        int d_index = static_cast < int > ( 10,0 * d_threshold / 5,0 );
        int index = static_cast < int > ( 10,0 * distance_vect [i] / 5.0 );
        si (distance_vect [i] <= d_threshold) 
        { 
            face_center_points2.push_back (PT2); 
            distance_vect2.push_back (distance_vect [i]); 
        } 
        Autre  
        {
            out_index [i] = -1 ; 
        } 
        Face_center_points.push_back (PT2); 
    } 

    / * ****************离散点的区域划分************************ * / 
    KDT :: arbre KDTree; 
    tree.setInputPointCloud (face_center_points2); 
    tree.setNumOfLeafData ( 100 ); 
    tree.buildKDTree (); 

    à double densité = 0,0 ;
    si (caculateDensity (face_center_points2, densité) == - 1 ) { 
        std :: Cout << " caculateDensity () a échoué !!! " << std :: endl;
        retourner -1 ; 
    } 

    Const à  double delta_threshold = 1,49999 ;  // 0,3-3,0 
    const  float searchRadius = 3,0 densité *;   // 点云平均密度的1-3倍

    // std :: vector <std :: vector <int >> region_vector; 
    std :: vector < int > index_ (face_center_points2.size ());
    pour (size_t i = 0 ; i <face_center_points2.size (); i ++ ) 
    { 
        si (index_ [i] == - 1 ) 
        { 
            continue ; 
        } 

        Std :: vector <int >Région_;
        deux mid_d = 0,0 ; 

        / * ****************迭代循环搜索*********************** * / 
        region_.push_back ( je); 
        index_ [i] = - 1 ;
        int t = 0 ; 
        mid_d = distance_vect2 [i];
        tandis que (t < region_.size ()) 
        { 
            // mid_d = distance_vect2 [region_ [t]]; 
            const PointType searchPoint2 = face_center_points2 [region_ [t]]; 
            std :: vector <size_t> searchIndex2; 
            std :: vector < Float > searchDistance2;
            doubles dis = 0.0 ;
            int num = 0 ;
            si (tree.runKNNSearchRadius (searchPoint2, searchRadius, searchIndex2, searchDistance2)> 1 ) {
                 pour (size_t n = 0 ; n <searchIndex2.size (); n ++ ) 
                { 
                    si ! (index_ [searchIndex2 [n]] = - 1 && abs (distance_vect2 [searchIndex2 [n]] - mid_d) < delta_threshold) 
                    { 
                        region_.push_back (searchIndex2 [n]);
                        index_ [searchIndex2 [n]] = - 1  ;
                        DIS + = distance_vect2 [searchIndex2 [n]]; 
                        num ++ ; 
                    } 
                } 
            } 

            Mid_d = (+ dis mid_d * (region_.size () - num)) / region_.size (); 
            t ++ ; 
        } 
        // 存取大于的分域
        si (region_.size ()> num_threshold) 
        { 
            region_vector.push_back (region_); 
        } 
    } 

    Retour  0 ; 
}

 

effet: