Ponto agrupamento nuvem e região estimativa de limite

Ponto agrupamento nuvem e região estimativa de limite

　　Ponto de nuvem de dados para as determinadas características e agrupamento divisão regular, o trabalho propõe um método de agrupamento e as características espaciais da fusão, e na região de detecção do limite com base no agrupamento (de um lado do artigo que é método mencionado), a idéia específica do algoritmo é a seguinte:

(1) pré-tratamento ponto de nuvem , bombeando grega, e similares para secar .

(2) não pode ser removido áreas divididas;

(3) O que se segue é a área restante da divisória conjunto, seleccionando x máximo de superfície como uma pesquisa cara semente começou , a pesquisa para o raio adjacente, um raio é R , quando o raio R procurou dentro n os triângulos, estes triângulos Comparativo média ponderada superfície mid_d limiar de diferença é conjunto delta_d, se a diferença for menor do que a distância valor limiar delta_d , então a busca para ser um aglomerado triangular cara Custer integração, de outra forma, sem fusão, e depois há uma nova superfície de entrada rosto semente, continuar a procurar o exposto, e calcula um novo campo média ponderada mid_d . Esta iteração até que toda a divisão completa de todos os clusters.

 

diagrama esquemático

(4) pode ser obtido por O terceiro passo muitas agrupamento Custers , através de todos os conjuntos Custers , desde que o número mínimo de pontos ou limiar área A3 , excluindo uma área de menos do que A3 agrupamento Custer ; cada Custer detecção limite de superfície Triangulate e integração.

(5) para detectar um limite da quarta etapa, o tratamento serrilha, processamento de alisamento principalmente limite, existe um limite de intensidade de alisamento dis_threshold , como um limite de área ; retornar os dados área limite.

(Nota: O terceiro passo principal é a de dividir o em dois passos, um passo Teoria cluster)

 

Parte do código:

int Divisão ( 
    std :: vector <PointType> & in_points, 
    std :: vector <PCTTM_TriangleFace> & face_vect, 
    std :: vector < double > & distance_vect, 
    std :: vector <PointType> & face_center_points2, 
    std :: vector <std: : vector < int >> & region_vector, 
     const  double & d_threshold, 
     const  int & num_threshold) { 

    se (in_points.size () < 3 || face_vect.size () == 0 || distance_vect.tamanho () == 0 )
    { 
        Std :: cout << " in_points.size () <3 || face_vect.size () == 0 || distance_vect.size () == 0 " << std :: endl;
        voltar - 1 ; 
    } 

    Std :: vector <PointType> face_center_points;
    // std :: vector <point3f_rgba> face_center_points2;
    // 计算三角面几何中心 
    std :: vector < double > distance_vect2;     // 剔除灰色 
    std :: vector < int > out_index (face_vect.size ());
    para (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 índice = static_cast < int > ( 10,0 * distance_vect [i] / 5,0 );
        se (distance_vect [i] <= d_threshold) 
        { 
            face_center_points2.push_back (pt2); 
            distance_vect2.push_back (distance_vect [i]); 
        } 
        Else 
        {
            out_index [i] = -1 ; 
        } 
        Face_center_points.push_back (pt2); 
    } 

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

    dupla densidade = 0,0 ;
    se (caculateDensity (face_center_points2, densidade) == - 1 ) { 
        std :: cout << " caculateDensity () falhou !!! " << std :: endl;
        voltar - 1 ; 
    }

     Const  duplo delta_threshold = 1,49999 ;  // 0,3-3,0 
    const  flutuador searchRadius = 3,0 densidade *;   // 点云平均密度的1-3倍

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

        Std :: vector <int  >region_;
        double mid_d = 0,0 ; 

        / * ****************迭代循环搜索*********************** * / 
        region_.push_back ( Eu); 
        index_ [i] = - 1 ;
        int t = 0 ; 
        mid_d = distance_vect2 [i];
        enquanto (t < region_.size ()) 
        { 
            // mid_d = distance_vect2 [region_ [t]]; 
            const PointType searchPoint2 = face_center_points2 [region_ [t]]; 
            std :: vector <size_t> searchIndex2; 
            std :: vector < Flutuar > searchDistance2;
            duplas dis = 0,0 ;
            int num = 0 ;
            se (tree.runKNNSearchRadius (searchPoint2, searchRadius, searchIndex2, searchDistance2)> 1 ) {
                 para (size_t n = 0 ; n <searchIndex2.size (); n ++ ) 
                { 
                    se ! (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 ++ ; 
        } 
        // 存取大于的分域
        se (region_.size ()> num_threshold) 
        { 
            region_vector.push_back (region_); 
        } 
    } 

    Retornar  0 ; 
}

 

efeito: