示例#1
0
void segment_segment_distance( const Vec3d& x0, unsigned int index0,
                              const Vec3d& x1, unsigned int index1,
                              const Vec3d& x2, unsigned int index2,
                              const Vec3d& x3, unsigned int index3,
                              double& distance  )
{
   check_edge_edge_proximity( x0, x1, x2, x3, distance );
}
示例#2
0
void segment_segment_distance( const Vec3d& x0, unsigned int index0,
                              const Vec3d& x1, unsigned int index1,
                              const Vec3d& x2, unsigned int index2,
                              const Vec3d& x3, unsigned int index3,
                              double& distance, 
                              double& bary0, double& bary2,
                              Vec3d& normal )
{
   check_edge_edge_proximity( x0, x1, x2, x3, distance, bary0, bary2, normal );
}
示例#3
0
void MeshMerger::process_mesh( )
{
    
    std::queue<Vec2st> edge_edge_candidates;
    
    //
    // Check edge-edge proximities for zippering candidates
    //
    
    bool merge_occured = true;
    
    while ( merge_occured )
    {
        merge_occured = false;
        
        // sorted by proximity so we merge closest pairs first
        std::vector<SortableEdgeEdgeProximity> proximities;
        
        for(size_t i = 0; i < m_surf.m_mesh.m_edges.size(); i++)
        {
            const Vec2st& e0 = m_surf.m_mesh.m_edges[i];
            
            if ( e0[0] == e0[1] ) { continue; }
            if ( m_surf.edge_is_solid(i) ) { continue; }
            
            if ( m_surf.m_mesh.m_is_boundary_vertex[ e0[0] ] || m_surf.m_mesh.m_is_boundary_vertex[ e0[1] ] )  { continue; }  // skip boundary vertices
            
            Vec3d emin, emax;
            m_surf.edge_static_bounds(i, emin, emax);
            emin -= m_surf.m_merge_proximity_epsilon * Vec3d(1,1,1);
            emax += m_surf.m_merge_proximity_epsilon * Vec3d(1,1,1);
            
            std::vector<size_t> edge_candidates;
            m_surf.m_broad_phase->get_potential_edge_collisions( emin, emax, false, true, edge_candidates );
            
            for(size_t j = 0; j < edge_candidates.size(); j++)
            {
                size_t proximal_edge_index = edge_candidates[j];
                const Vec2st& e1 = m_surf.m_mesh.m_edges[proximal_edge_index];
                
                if ( proximal_edge_index <= i )
                {
                    continue;
                }
                
                if ( m_surf.m_mesh.m_is_boundary_vertex[ e1[0] ] || m_surf.m_mesh.m_is_boundary_vertex[ e1[1] ] )  { continue; }  // skip boundary vertices
                
                if(e0[0] != e1[0] && e0[0] != e1[1] && e0[1] != e1[0] && e0[1] != e1[1])
                {
                    double distance, s0, s2;
                    Vec3d normal;
                    
                    check_edge_edge_proximity(m_surf.get_position(e0[0]), 
                                              m_surf.get_position(e0[1]), 
                                              m_surf.get_position(e1[0]), 
                                              m_surf.get_position(e1[1]), 
                                              distance, s0, s2, normal );
                    
                    if (distance < m_surf.m_merge_proximity_epsilon)
                    {
                        
                        if ( m_surf.m_verbose ) 
                        { 
                            std::cout << "proximity: " << distance << " / " << m_surf.m_merge_proximity_epsilon << std::endl; //proximities[i].distance << std::endl; 
                        }
                        
                        if ( zipper_edges( i, proximal_edge_index ) )
                        {
                            
                            m_surf.trim_non_manifold( m_surf.m_dirty_triangles );
                            
                            if ( m_surf.m_verbose ) 
                            { 
                                std::cout << "zippered" << std::endl; 
                            }
                            
                            merge_occured = true;
                        }
                        
                    }
                }
            }
        }
        
        if ( merge_occured )
        {
            m_surf.assert_no_degenerate_triangles();
        }
        
    }       // while ( merge_occured )
    
}