SkinMesh.cpp

Go to the documentation of this file.

#include <iostream>
#include <cstdlib>
#include "MBCore.hpp"
#include "MBRange.hpp"
#include "MBTagConventions.hpp"
 
// Hold edges in an array of vertex handles.
struct edge
{
    MBEntityHandle v0;
    MBEntityHandle v1;
};
 
// edge structure comparision function for qsort
// If the first vertex handle is the same, compare the second.
int compare_edge( const void* a, const void* b )
{
    struct edge* ia = (struct edge*)a;
    struct edge* ib = (struct edge*)b;
    if( ia->v0 == ib->v0 )
    {
        return (int)( 100.f * ia->v1 - 100.f * ib->v1 );
    }
    else
    {
        return (int)( 100.f * ia->v0 - 100.f * ib->v0 );
    }
}
 
// This skinner is fast partly because it assumes that no edges exist in the MOAB
// instance. Checking to see if an edge exists before creating a new one is slow.
MBErrorCode skin_tris( MBInterface* mb, MBRange tris, MBRange& skin_edges )
{
 
    // Empty the output range and make sure that the input range is only tris
    skin_edges.clear();
    if( tris.empty() ) return MB_ENTITY_NOT_FOUND;
    if( !tris.all_of_type( MBTRI ) ) return MB_FAILURE;
 
    // Remove edges from the instance.
    int n_edges;
    MBErrorCode rval = mb->get_number_entities_by_type( 0, MBEDGE, n_edges );
    if( MB_SUCCESS != rval ) return rval;
    if( 0 != n_edges )
    {
        std::cerr << "skin_tris: failed because " << n_edges << " edges exist in the MOAB instance" << std::endl;
        return MB_FAILURE;
    }
 
    // Get connectivity. Do not create MBEdges.
    edge* edges = new edge[3 * tris.size()];
    int n_verts;
    int ii = 0;
    for( MBRange::iterator i = tris.begin(); i != tris.end(); ++i )
    {
        const MBEntityHandle* conn;
        rval = mb->get_connectivity( *i, conn, n_verts );
        if( MB_SUCCESS != rval ) return rval;
        if( 3 != n_verts ) return MB_FAILURE;
        // points should not be degenerate
        if( conn[0] == conn[1] || conn[1] == conn[2] || conn[2] == conn[0] )
        {
            std::cerr << "skin_tris: degenerate triangle" << std::endl;
            return MB_FAILURE;
        }
 
        // make edges
        edges[3 * ii + 0].v0 = conn[0];
        edges[3 * ii + 0].v1 = conn[1];
        edges[3 * ii + 1].v0 = conn[1];
        edges[3 * ii + 1].v1 = conn[2];
        edges[3 * ii + 2].v0 = conn[2];
        edges[3 * ii + 2].v1 = conn[0];
        ii++;
    }
 
    // Ensure that the first vertex handle is the lowest
    for( unsigned int i = 0; i < 3 * tris.size(); ++i )
    {
        if( edges[i].v0 > edges[i].v1 )
        {
            MBEntityHandle temp = edges[i].v0;
            edges[i].v0         = edges[i].v1;
            edges[i].v1         = temp;
        }
    }
 
    // Sort by first handle, then second handle.
    qsort( edges, 3 * tris.size(), sizeof( struct edge ), compare_edge );
 
    // Go through array, saving edges that are not paired.
    for( unsigned int i = 0; i < 3 * tris.size(); i++ )
    {
        // If the last edge has not been paired, create it. This avoids overrunning
        // the edges array with i+1.
        if( 3 * tris.size() - 1 == i )
        {
            const MBEntityHandle conn[2] = { edges[i].v0, edges[i].v1 };
            MBEntityHandle edge;
            rval = mb->create_element( MBEDGE, conn, 2, edge );
            if( MB_SUCCESS != rval ) return rval;
            skin_edges.insert( edge );
 
            // If a match exists, skip ahead
        }
        else if( edges[i].v0 == edges[i + 1].v0 && edges[i].v1 == edges[i + 1].v1 )
        {
            i++;
            // test to make sure surface is manifold
            while( edges[i].v0 == edges[i + 1].v0 && edges[i].v1 == edges[i + 1].v1 )
            {
                std::cout << "find_skin WARNING: non-manifold edge" << std::endl;
                mb->list_entity( edges[i].v0 );
                mb->list_entity( edges[i].v1 );
                ++i;
            }
            // otherwise a skin edge has been found
        }
        else
        {
            const MBEntityHandle conn[2] = { edges[i].v0, edges[i].v1 };
            MBEntityHandle edge;
            rval = mb->create_element( MBEDGE, conn, 2, edge );
            if( MB_SUCCESS != rval ) return rval;
            skin_edges.insert( edge );
        }
    }
    delete[] edges;
    return MB_SUCCESS;
}
 
// Skin triangles to recover edges.
// Triangles are contained in surface sets.
int main( int argc, char** argv )
{
    if( 1 == argc )
    {
        std::cout << "Usage: " << argv[0] << " <filename>" << std::endl;
        return 0;
    }
 
    // get MOAB instance and read the file
    MBCore* mb       = new MBCore();
    MBErrorCode rval = mb->load_file( argv[1] );
    if( MB_SUCCESS != rval ) return 0;
 
    // this optimized skinner requires removing all MBEdges from the MOAB instance
    MBRange edges;
    rval = mb->get_entities_by_type( 0, MBEDGE, edges );
    if( MB_SUCCESS != rval ) return 0;
    if( !edges.empty() ) std::cout << "Warning: deleting all MBEdges" << std::endl;
    rval = mb->delete_entities( edges );
    if( MB_SUCCESS != rval ) return 0;
 
    // get surface sets
    MBTag geom_tag;
    rval = mb->tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geom_tag );
    if( MB_SUCCESS != rval ) return 0;
    MBRange surf_sets;
    int two     = 2;
    void* dim[] = { &two };
    rval        = mb->get_entities_by_type_and_tag( 0, MBENTITYSET, &geom_tag, dim, 1, surf_sets );
    if( MB_SUCCESS != rval ) return 0;
 
    // skin each surface
    for( MBRange::iterator i = surf_sets.begin(); i != surf_sets.end(); ++i )
    {
 
        // get triangles in the surface set
        MBRange tris;
        rval = mb->get_entities_by_type( *i, MBTRI, tris );
        if( MB_SUCCESS != rval ) return 0;
 
        // call the skinning function
        MBRange skin_edges;
        rval = skin_tris( mb, tris, skin_edges );
        if( MB_SUCCESS != rval ) return 0;
 
        // do something with the result
        std::cout << "surface has " << skin_edges.size() << " skin edges" << std::endl;
 
        // remove the edges for the optimized skinner
        rval = mb->delete_entities( skin_edges );
        if( MB_SUCCESS != rval ) return 0;
    }
}