C++ SWIFT_Array类代码示例

int Upper_Leaves_CB( Togl *togl, int argc, const char *argv[] )
{
    int i;

    if( uleaves ) {
        // Include all leaves above the current level
        for( i = 0; i < num_leaves; i++ ) {
            if( leaves[i]->Level() < level ) {
                which_pieces.Add_Grow( leaves[i], 10 );
            }
        }
    } else {
        // Remove all leaves above the current level
        SWIFT_Array<SWIFT_BV*> new_which_pieces;

        new_which_pieces.Create( which_pieces.Length() );
        new_which_pieces.Set_Length( 0 );
        for( i = 0; i < which_pieces.Length(); i++ ) {
            if( !which_pieces[i]->Is_Leaf() ||
                which_pieces[i]->Level() == level
            ) {
                // Keep this piece
                new_which_pieces.Add( which_pieces[i] );
            }
        }

        which_pieces.Destroy();
        which_pieces = new_which_pieces;
        new_which_pieces.Nullify();
    }

    Togl_PostRedisplay( t );
    return TCL_OK;
}

void Create_One_Piece( SWIFT_Tri_Mesh* m, SWIFT_Array<int>& piece_ids,
                       SWIFT_Array< SWIFT_Array<int> >& mfs,
                       SWIFT_Array< SWIFT_Array<SWIFT_Tri_Face> >& vfs )
{
    int i;

    piece_ids.Create( m->Num_Faces() );
    mfs.Create( 1 );
    mfs[0].Create( m->Num_Faces() );
    for( i = 0; i < m->Num_Faces(); i++ ) {
        mfs[0][i] = i;
        piece_ids[i] = 0;
    }

    vfs.Create( 1 );
}

int Key_K_CB( Togl *togl, int argc, const char *argv[] )
{
    if( dh == DRAW_HIERARCHY ) {
        if( which_pieces.Length() != 1 ) {
            // Go up the hierarchy
            int i;
            SWIFT_Array<SWIFT_BV*> new_which_pieces( which_pieces.Length() );
            SWIFT_BV* parent;

            new_which_pieces.Set_Length( 0 );
            parent = NULL;
            for( i = 0; i < which_pieces.Length(); i++ ) {
                if( uleaves && which_pieces[i]->Is_Leaf() &&
                    which_pieces[i]->Level() < level
                ) {
                    new_which_pieces.Add( which_pieces[i] );
                } else if( parent != which_pieces[i]->Parent() ) {
                    parent = which_pieces[i]->Parent();
                    new_which_pieces.Add( parent );
                }
            }

            level--;

            // Include the new leaves at this level if uleaves is false
            if( !uleaves ) {
                for( i = 0; i < num_leaves; i++ ) {
                    if( leaves[i]->Level() == level ) {
                        new_which_pieces.Add_Grow( leaves[i], 10 );
                    }
                }
            }

            which_pieces.Destroy();
            which_pieces = new_which_pieces;
            new_which_pieces.Nullify();
        }
    } else {
            // Show next convex piece and set text field
            char temp[80];

            if( which_cps.Length() == 0 ) {
                which_cps.Set_Length( 1 );
                which_cps[0] = 0;
            } else {
                which_cps[0] = (which_cps[0] == which_cps.Max_Length()-1 ?
                                                0 : which_cps[0]+1);
                which_cps.Set_Length( 1 );
            }
            sprintf( temp, "set which_cps %d", which_cps[0] );
            Tcl_Eval( Togl_Interp( togl ), temp );
    }

    Togl_PostRedisplay( togl );
    return TCL_OK;
}

void Compute_Convex_Hull( SWIFT_Array<SWIFT_Tri_Vertex>& vs, int*& fs, int& fn )
{
    int i;
    //coordT *qhv = new coordT[vs.Length()*3];
    coordT *qhv = (coordT*)malloc( sizeof(coordT)*vs.Length()*3 );
    coordT *p = qhv;

    // Load the coordinates into the vertex array for qhull since SWIFT_Real
    // may not be the same type.
    for( i = 0; i < vs.Length(); i++ ) {
        *p++ = vs[i].Coords().X();
        *p++ = vs[i].Coords().Y();
        *p++ = vs[i].Coords().Z();
    }

    Compute_Convex_Hull( qhv, vs.Length(), fs, fn );

    // Do not delete these here since they are deleted in the qh_init_B fcn
    //free( qhv );
    //delete qhv;
}

int Key_J_CB( Togl *togl, int argc, const char *argv[] )
{
    if( dh == DRAW_HIERARCHY ) {
        int i, j;
        bool advanced = false;
        SWIFT_Array<SWIFT_BV*> new_which_pieces( 100 );

        new_which_pieces.Set_Length( 0 );
        for( i = 0; i < which_pieces.Length(); i++ ) {
            if( uleaves && which_pieces[i]->Is_Leaf() ) {
                // Keep this leaf
                new_which_pieces.Add_Grow( which_pieces[i], 10 );
            } else {
                for( j = 0; j < which_pieces[i]->Num_Children(); j++ ) {
                    new_which_pieces.Add_Grow(
                                        which_pieces[i]->Children()[j], 10 );
                    advanced = true;
                }
            }
        }

        if( advanced ) {
            level++;
            which_pieces.Destroy();
            which_pieces = new_which_pieces;
            new_which_pieces.Nullify();
        }
    } else {
            // Show previous convex piece and set text field
            char temp[80];

            if( which_cps.Length() == 0 ) {
                which_cps.Set_Length( 1 );
                which_cps[0] = 0;
            } else {
                which_cps[0] = (which_cps[0] == 0 ?
                                   which_cps.Max_Length()-1 : which_cps[0]-1);
                which_cps.Set_Length( 1 );
            }
            sprintf( temp, "set which_cps %d", which_cps[0] );
            Tcl_Eval( Togl_Interp( togl ), temp );
    }

    Togl_PostRedisplay( togl );
    return TCL_OK;
}

int Convex_Pieces_CB( Togl *togl, int argc, const char *argv[] )
{
    if( argv[2][0] == 'A' || argv[2][0] == 'a' ) {
        // Want to draw all pieces
        int i;
        which_cps.Set_Length( which_cps.Max_Length() );
        for( i = 0; i < which_cps.Length(); i++ ) {
            which_cps[i] = i;
        }
    } else {
        // Parse the string to determine which ones to draw
        long upper, lower;
        const char* str = argv[2];
        char* endp;
        int i;
        SWIFT_Array<int> which_cps_back = which_cps;

        which_cps.Set_Length( 0 );

        while( *str != '\0' && which_cps.Length() != which_cps.Max_Length() ) {
            if( isdigit( *str ) ) {
                // Read the next segment
                lower = strtol( str, &endp, 10 );
                str = endp;
                if( lower < 0 ) {
                    lower = 0;
                }
                if( lower >= which_cps.Max_Length() ) {
                    lower = which_cps.Max_Length()-1;
                }
                upper = lower;
                if( *str == '-' ) {
                    str++;
                    if( isdigit( *str ) ) {
                        upper = strtol( str, &endp, 10 );
                        str = endp;
                        if( upper < 0 ) {
                            upper = 0;
                        }
                        if( upper >= which_cps.Max_Length() ) {
                            upper = which_cps.Max_Length()-1;
                        }
                        if( upper < lower ) {
                            int j = lower;
                            lower = upper;
                            upper = j;
                        }
                    } else {
                        cerr << "Error: Expecting number after '-'" << endl;
                        which_cps = which_cps_back;
                        break;
                    }
                }

                // Save the segment
                for( i = lower; i <= upper &&
                     which_cps.Length() != which_cps.Max_Length(); i++
                ) {
                    which_cps.Add( i );
                }

                // Done this segment
                if( *str == ',' ) {
                    str++;
                } else {
                    // Assume that we found the end of the list
                    break;
                }
            } else {
                break;
            }
        }
    }

    Togl_PostRedisplay( t );
    return TCL_OK;
}

int Decompose_DFS( SWIFT_Tri_Mesh* m, SWIFT_Array<int>& piece_ids,
                   SWIFT_Array< SWIFT_Array<int> >& mfs,
                   SWIFT_Array< SWIFT_Array<SWIFT_Tri_Face> >& vfs,
                   bool random )
{
    // Start performing DFS on the dual graph maintaining a convex hull along
    // the way.

    cerr << endl << "Starting ";
    if( random ) { 
        cerr << "randomized ";
    }
    cerr << "DFS decomposition" << endl;

    const unsigned int max_faces_in_a_chull = (m->Num_Vertices() - 2) << 1;
    int i, j, k, l, p;
    int created_faces = 0;
    int top, id;
    // The faces stack
    SWIFT_Array<SWIFT_Tri_Face*> sfs;
    // Keeps track of all the faces that were marked as failed so that they can
    // be unmarked efficiently.
    SWIFT_Array<SWIFT_Tri_Face*> mark_failed;
    // The current convex hull
    SWIFT_Array<SWIFT_Tri_Face> chull;
    // Pointers to faces indicating whether the face on the convex hull is a
    // model face or a virtual face (entry is NULL)
    SWIFT_Array<SWIFT_Tri_Face*> cfs;
    // Which faces on the original model are allowed to be added
    SWIFT_Array<bool> fallowed;
    // Which vertices exist on the convex hull
    SWIFT_Array<bool> cvs;
    // Ids of vertices belonging to the convex hull 
    SWIFT_Array<int> cvs_idx;
    // Ids of faces that are added at each iteration
    SWIFT_Array<int> addedfs;
    // The model face ids that belong to a single convex hull
    SWIFT_Array<int> temp_mfs_1d;
    // The model face ids that belong to each convex hull
    SWIFT_Array< SWIFT_Array<int> > temp_mfs_2d;

    sfs.Create( m->Num_Faces() );
    mark_failed.Create( m->Num_Faces() );
    chull.Create( max_faces_in_a_chull );
    cfs.Create( max_faces_in_a_chull );
    fallowed.Create( m->Num_Faces() );
    cvs.Create( m->Num_Vertices() );
    cvs_idx.Create( m->Num_Vertices() );
    addedfs.Create( m->Num_Faces() );
    temp_mfs_1d.Create( m->Num_Faces() );
    temp_mfs_2d.Create( m->Num_Faces() );

    vfs.Create( m->Num_Faces() );
    piece_ids.Create( m->Num_Faces() );

    Prepare_Mesh_For_Decomposition( m );

    for( i = 0; i < m->Num_Faces(); i++ ) {
        fallowed[i] = true;
    }
    for( i = 0; i < m->Num_Vertices(); i++ ) {
        cvs[i] = false;
    }
    cvs_idx.Set_Length( 0 );

    id = 0;
    for( p = 0; p < m->Num_Faces(); ) {
        // Try to advance p
        for( ; p < m->Num_Faces() && m->Faces()[p].Marked(); p++ );
        if( p == m->Num_Faces() ) break;
        if( random ) {
            // Find a random i in the range [p,m->Num_Faces()-1]
            while( m->Faces()[i = (int) ((SWIFT_Real)(m->Num_Faces()-p) *
                                         drand48()) + p].Marked() );
        } else {
            i = p;
        }

        top = 0;
        sfs[0] = m->Faces()(i);
        mark_failed.Set_Length( 0 );
        temp_mfs_1d.Set_Length( 0 );

        Create_First_Face( m->Faces()(i), chull, cfs );

        // Unset all the vertex membership flags
        for( j = 0; j < cvs_idx.Length(); j++ ) { 
            cvs[cvs_idx[j]] = false;
        }
        cvs_idx.Set_Length( 0 );

        // Mark the first three vertices as added to the hull
        cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge1().Origin() ) );
        cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge2().Origin() ) );
        cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge3().Origin() ) );
        cvs[cvs_idx[0]] = true;
        cvs[cvs_idx[1]] = true;
        cvs[cvs_idx[2]] = true;

        // Add the first face
//.........这里部分代码省略.........

int Decompose_Cresting_BFS( SWIFT_Tri_Mesh* m, SWIFT_Array<int>& piece_ids,
                            SWIFT_Array< SWIFT_Array<int> >& mfs,
                            SWIFT_Array< SWIFT_Array<SWIFT_Tri_Face> >& vfs )
{
    // Start performing BFS on the dual graph maintaining a convex hull along
    // the way.

    cerr << endl << "Starting cresting BFS decomposition" << endl;

    const unsigned int max_faces_in_a_chull = (m->Num_Vertices() - 2) << 1;
    int i, j, k, l;
    int created_faces = 0;
    int front, id;
    bool add_children;
    SWIFT_Tri_Edge* e;
    SWIFT_Tri_Vertex* v;
    SWIFT_Array<SWIFT_Tri_Face*> qfs;   // The queue
    SWIFT_Array<SWIFT_Tri_Face*> qfs_parents;
    SWIFT_Array<int> qmap;
    SWIFT_Array<int> qmap_idx;
    SWIFT_Array<SWIFT_Tri_Face*> mark_failed;
    SWIFT_Array<SWIFT_Tri_Face> chull;
    SWIFT_Array<SWIFT_Tri_Face*> cfs;
    SWIFT_Array<bool> fallowed;
    SWIFT_Array<bool> cvs;
    SWIFT_Array<int> cvs_idx;
    SWIFT_Array<int> addedfs;
    SWIFT_Array<int> temp_mfs_1d;
    SWIFT_Array< SWIFT_Array<int> > temp_mfs_2d;

    // The priority queue
    SWIFT_Array<int> lengths( m->Num_Faces() );
    SWIFT_Array<int> bmap( m->Num_Faces() );
    SWIFT_Array<int> fmap( m->Num_Faces() );

    qfs.Create( m->Num_Faces() );
    qfs_parents.Create( m->Num_Faces() );
    qmap.Create( m->Num_Faces() );
    qmap_idx.Create( m->Num_Faces() );
    mark_failed.Create( m->Num_Faces() );
    chull.Create( max_faces_in_a_chull );
    cfs.Create( max_faces_in_a_chull );
    fallowed.Create( m->Num_Faces() );
    cvs.Create( m->Num_Vertices() );
    cvs_idx.Create( m->Num_Vertices() );
    addedfs.Create( m->Num_Faces() );
    temp_mfs_1d.Create( m->Num_Faces() );
    temp_mfs_2d.Create( m->Num_Faces() );

    vfs.Create( m->Num_Faces() );
    piece_ids.Create( m->Num_Faces() );

    Prepare_Mesh_For_Decomposition( m );

    cvs_idx.Set_Length( 0 );
    qmap_idx.Set_Length( 0 );
    for( i = 0; i < m->Num_Vertices(); i++ ) {
        cvs[i] = false;
    }
    for( i = 0; i < m->Num_Faces(); i++ ) {
        fallowed[i] = true;
        piece_ids[i] = -1;
        qmap[i] = -1;
        bmap[i] = fmap[i] = i;
        if( m->Faces()[i].Edge1().Unmarked() ||
            m->Faces()[i].Edge2().Unmarked() ||
            m->Faces()[i].Edge3().Unmarked()
        ) {
            lengths[i] = 0;
            qmap_idx.Add( i );
        } else {
            lengths[i] = -1;
        }
    }

    id = 0;

    // Calculate distances for each face and create priority queue
    if( !qmap_idx.Empty() ) {
        // This is a convex object
        for( i = 0; i < qmap_idx.Max_Length(); i++ ) {
            if( m->Faces()[qmap_idx[i]].Edge1().Twin() != NULL ) {
                k = m->Face_Id(
                        m->Faces()[qmap_idx[i]].Edge1().Twin()->Adj_Face() );
                if( lengths[k] == -1 ) {
                    lengths[k] = lengths[qmap_idx[i]]+1;
                    qmap_idx.Add( k );
                }
            }
            if( m->Faces()[qmap_idx[i]].Edge2().Twin() != NULL ) {
                k = m->Face_Id(
                        m->Faces()[qmap_idx[i]].Edge2().Twin()->Adj_Face() );
                if( lengths[k] == -1 ) {
                    lengths[k] = lengths[qmap_idx[i]]+1;
                    qmap_idx.Add( k );
                }
            }
            if( m->Faces()[qmap_idx[i]].Edge3().Twin() != NULL ) {
                k = m->Face_Id(
                        m->Faces()[qmap_idx[i]].Edge3().Twin()->Adj_Face() );
//.........这里部分代码省略.........

void Edge_Flip( SWIFT_Tri_Mesh* m, SWIFT_Real etol )
{
    const SWIFT_Real etol_sq = etol*etol;
    int i;
    SWIFT_Tri_Face f;
    SWIFT_Array<SWIFT_Tri_Edge*> fedges;

    // Have all the convex edges marked
    Prepare_Mesh_For_Decomposition( m );

    // Traverse all the faces, marking edges that are not allowed to be flipped
    for( i = 0; i < m->Num_Faces(); i++ ) {
        if( m->Faces()[i].Edge1().Unmarked() ) {
            // May be able to flip this edge

            // Build the proposed edge
            f.Edge1().Set_Origin( m->Faces()[i].Edge3().Origin() );
            f.Edge2().Set_Origin(
                            m->Faces()[i].Edge1().Twin()->Prev()->Origin() );
            f.Edge1().Compute_Direction_Length();
            if( Edge_Flip_Allowed( m->Faces()[i].Edge1P(), f.Edge1P(), etol_sq )
            ) {
                fedges.Add_Grow( m->Faces()[i].Edge1P(), 100 );
                // Have to mark other edges in these two faces as well as
                // their twins
                m->Faces()[i].Edge2().Mark();
                m->Faces()[i].Edge2().Twin()->Mark();
                m->Faces()[i].Edge3().Mark();
                m->Faces()[i].Edge3().Twin()->Mark();

                m->Faces()[i].Edge1().Twin()->Next()->Mark();
                m->Faces()[i].Edge1().Twin()->Next()->Twin()->Mark();
                m->Faces()[i].Edge1().Twin()->Prev()->Mark();
                m->Faces()[i].Edge1().Twin()->Prev()->Twin()->Mark();
            }
            m->Faces()[i].Edge1().Mark();
            m->Faces()[i].Edge1().Twin()->Mark();
        }
        if( m->Faces()[i].Edge2().Unmarked() ) {
            // May be able to flip this edge

            // Build the proposed edge
            f.Edge1().Set_Origin( m->Faces()[i].Edge1().Origin() );
            f.Edge2().Set_Origin(
                            m->Faces()[i].Edge2().Twin()->Prev()->Origin() );
            f.Edge1().Compute_Direction_Length();
            if( Edge_Flip_Allowed( m->Faces()[i].Edge2P(), f.Edge1P(), etol_sq )
            ) {
                fedges.Add_Grow( m->Faces()[i].Edge2P(), 100 );
                m->Faces()[i].Edge1().Mark();
                m->Faces()[i].Edge1().Twin()->Mark();
                m->Faces()[i].Edge3().Mark();
                m->Faces()[i].Edge3().Twin()->Mark();

                m->Faces()[i].Edge2().Twin()->Next()->Mark();
                m->Faces()[i].Edge2().Twin()->Next()->Twin()->Mark();
                m->Faces()[i].Edge2().Twin()->Prev()->Mark();
                m->Faces()[i].Edge2().Twin()->Prev()->Twin()->Mark();
            }
            m->Faces()[i].Edge2().Mark();
            m->Faces()[i].Edge2().Twin()->Mark();
        }
        if( m->Faces()[i].Edge3().Unmarked() ) {
            // May be able to flip this edge

            // Build the proposed edge
            f.Edge1().Set_Origin( m->Faces()[i].Edge2().Origin() );
            f.Edge2().Set_Origin(
                            m->Faces()[i].Edge3().Twin()->Prev()->Origin() );
            f.Edge1().Compute_Direction_Length();
            if( Edge_Flip_Allowed( m->Faces()[i].Edge3P(), f.Edge1P(), etol_sq )
            ) {
                fedges.Add_Grow( m->Faces()[i].Edge3P(), 100 );
                m->Faces()[i].Edge1().Mark();
                m->Faces()[i].Edge1().Twin()->Mark();
                m->Faces()[i].Edge2().Mark();
                m->Faces()[i].Edge2().Twin()->Mark();

                m->Faces()[i].Edge3().Twin()->Next()->Mark();
                m->Faces()[i].Edge3().Twin()->Next()->Twin()->Mark();
                m->Faces()[i].Edge3().Twin()->Prev()->Mark();
                m->Faces()[i].Edge3().Twin()->Prev()->Twin()->Mark();
            }
            m->Faces()[i].Edge3().Mark();
            m->Faces()[i].Edge3().Twin()->Mark();
        }
    }

    cerr << "Flipped " << fedges.Length() << " edges" << endl;

    // Do the actual swaps
    for( i = 0; i < fedges.Length(); i++ ) {
        SWIFT_Tri_Edge* t1 = fedges[i]->Prev()->Twin();
        SWIFT_Tri_Edge* t2 = fedges[i]->Twin()->Prev()->Twin();

        // Set the origins
        fedges[i]->Set_Origin( fedges[i]->Twin()->Prev()->Origin() );
        fedges[i]->Twin()->Set_Origin( fedges[i]->Prev()->Origin() );

        // Set the flipped edge twins
//.........这里部分代码省略.........

void Compute_Spread( SWIFT_Array<SWIFT_Tri_Vertex>& vs, SWIFT_Triple& center,
                     bool compute_spreads,
                     SWIFT_Triple& min_dir, SWIFT_Real& min_spread,
                     SWIFT_Triple& mid_dir, SWIFT_Real& mid_spread,
                     SWIFT_Triple& max_dir, SWIFT_Real& max_spread )
{
    int fn;
    int* fs;

    if( vs.Length() == 3 ) {
        fs = new int[6];
        fs[0] = 0; fs[1] = 1; fs[2] = 2;
        fs[3] = 0; fs[4] = 2; fs[5] = 1;
        fn = 2;
    } else {
        Compute_Convex_Hull( vs, fs, fn );
    }

    Compute_Spread( vs, fs, fn, false, center, min_dir, mid_dir, max_dir );

    if( compute_spreads ) {
        // Now we have compute the spreads.  This can be done by inserting
        // convex hull vertices into an OBB or by doing hill climbing on the
        // convex hull.  We will go for the first option since building the
        // connectivity of the convex hull is too expensive.

        int i;
        SWIFT_Real min_min_spread = SWIFT_INFINITY;
        SWIFT_Real min_mid_spread = SWIFT_INFINITY;
        SWIFT_Real min_max_spread = SWIFT_INFINITY;
        min_spread = -SWIFT_INFINITY;
        mid_spread = -SWIFT_INFINITY;
        max_spread = -SWIFT_INFINITY;

        for( i = 0; i < fn*3; ) {
            const SWIFT_Triple& v1 = vs[fs[i++]].Coords();
            const SWIFT_Triple& v2 = vs[fs[i++]].Coords();
            const SWIFT_Triple& v3 = vs[fs[i++]].Coords();

            const SWIFT_Real min_dot1 = min_dir * v1;
            const SWIFT_Real min_dot2 = min_dir * v2;
            const SWIFT_Real min_dot3 = min_dir * v3;

            const SWIFT_Real mid_dot1 = mid_dir * v1;
            const SWIFT_Real mid_dot2 = mid_dir * v2;
            const SWIFT_Real mid_dot3 = mid_dir * v3;

            const SWIFT_Real max_dot1 = max_dir * v1;
            const SWIFT_Real max_dot2 = max_dir * v2;
            const SWIFT_Real max_dot3 = max_dir * v3;

            Min_And_Max( min_min_spread, min_spread, min_dot1 );
            Min_And_Max( min_min_spread, min_spread, min_dot2 );
            Min_And_Max( min_min_spread, min_spread, min_dot3 );

            Min_And_Max( min_mid_spread, mid_spread, mid_dot1 );
            Min_And_Max( min_mid_spread, mid_spread, mid_dot2 );
            Min_And_Max( min_mid_spread, mid_spread, mid_dot3 );

            Min_And_Max( min_max_spread, max_spread, max_dot1 );
            Min_And_Max( min_max_spread, max_spread, max_dot2 );
            Min_And_Max( min_max_spread, max_spread, max_dot3 );
        }

        // Recompute the center
        center = 0.5 * (SWIFT_Triple( max_spread, mid_spread, min_spread ) +
             SWIFT_Triple( min_max_spread, min_mid_spread, min_min_spread ));

        min_spread -= min_min_spread;
        mid_spread -= min_mid_spread;
        max_spread -= min_max_spread;
    }

    delete fs;
}

// Save a hierarchy file
bool Save_Hierarchy_File( const char* filename, SWIFT_Tri_Mesh* m,
                          SWIFT_Array<SWIFT_Tri_Face*>& st_faces,    
                          SWIFT_Array<SWIFT_Tri_Edge*>& st_twins )
{
    ofstream fout;

    // Try to open the file
    if( filename == NULL ) {
        cerr << "Error: Invalid filename given to write model" << endl;
        return false;
    }

#ifdef WIN32
    fout.open( filename, ios::out | ios::binary );
#else
    fout.open( filename, ios::out );
#endif

    if( !fout.rdbuf()->is_open( ) ) {
        cerr << "Error: file could not be opened for writing \""
             << filename << "\"" << endl;
        return false;
    }

    int i, j, k, l;
    int ntf, ncf, net;
    SWIFT_Array<int> bvq( m->Num_BVs() );
    SWIFT_Array<int> bvs_bmap( m->Num_BVs() );
    SWIFT_Array<int> flen_accum( m->Num_BVs()+1 );
    SWIFT_Array<int> cflen_accum( m->Num_BVs()+1 );
    SWIFT_Tri_Edge* e;
    SWIFT_Tri_Face* f;
    SWIFT_Real* vs;
    SWIFT_Real* vs_walk;
    int* fs;
    char* cs;

    fout << '\0';
    fout << "Convex_Hierarchy" << endl;

    if( machine_is_big_endian ) {
        fout << "binary big_endian" << endl;
    } else {
        fout << "binary little_endian" << endl;
    }

    if( sizeof(SWIFT_Real) == sizeof(float) ) {
        fout << "real float" << endl;
    } else {
        fout << "real double" << endl;
    }

    // Traverse the hierarchy BF counting stuff
    bvq.Set_Length( 0 );
    bvq.Add( 0 );
    bvs_bmap[0] = 0;

    ntf = m->Num_Faces();
    ncf = 0;
    net = 0;

    // Count total twin lengths
    for( i = 0; i < m->Num_Faces(); i++ ) {
        net += m->Faces()[i].Twins_Length();
    }
    
    flen_accum[0] = ntf;
    cflen_accum[0] = ncf;

    for( i = 0; i < bvq.Length(); i++ ) {
        for( j = 0; j < m->BVs()[bvq[i]].Num_Faces(); j++ ) {
            net += m->BVs()[bvq[i]].Faces()[j].Twins_Length();
        }
        ntf += m->BVs()[bvq[i]].Num_Faces();
        ncf += m->BVs()[bvq[i]].Num_Other_Faces();
        flen_accum[i+1] = ntf;
        cflen_accum[i+1] = ncf;
        if( m->BVs()[bvq[i]].Num_Children() != 0 ) {
            bvq.Add( m->BVs().Position( m->BVs()[bvq[i]].Children()[0] ) );
            bvs_bmap[bvq.Last()] = bvq.Length()-1;
            bvq.Add( m->BVs().Position( m->BVs()[bvq[i]].Children()[1] ) );
            bvs_bmap[bvq.Last()] = bvq.Length()-1;
        }
    }

    net *= 3;

    // Write out the counts
    fout << "vertices " << m->Num_Vertices() << endl;
    fout << "map_vids " << m->Map_Vertex_Ids().Length() << endl;
    fout << "map_fids " << m->Map_Face_Ids().Length() << endl;
    fout << "orig_faces " << m->Num_Faces() << endl;
    fout << "orig_hier_faces " << st_faces.Length() << endl;
    fout << "total_faces " << ntf << endl;
    fout << "copied_faces " << ncf << endl;
    fout << "edge_twins " << net << endl;
    fout << "nodes " << m->Num_BVs() << endl;

    // Write out the SWIFT_Tri_Mesh record
//.........这里部分代码省略.........

// Save a decomposition file
bool Save_Decomposition_File( const char* filename, SWIFT_Tri_Mesh* m,
                              SWIFT_Array<int>& piece_ids,
                              SWIFT_Array< SWIFT_Array<int> >& mfs,
                              SWIFT_Array< SWIFT_Array<SWIFT_Tri_Face> >& vfs )
{
    int i, j, k;
    int num_vfaces;
    int num_mfaces;
    ofstream fout;
    SWIFT_Real* vs;
    SWIFT_Real* vs_walk;
    int* fs;

    // Try to open the file
    if( filename == NULL ) {
        cerr << "Error: Invalid filename given to write decomp" << endl;
        return false;
    }

#ifdef WIN32
    fout.open( filename, ios::out | ios::binary );
#else
    fout.open( filename, ios::out );
#endif

    if( !fout.rdbuf()->is_open( ) ) {
        cerr << "Error: file could not be opened for writing \""
             << filename << "\"" << endl;
        return false;
    }

    fout << '\0';
    fout << "Convex_Decomposition" << endl;

    if( machine_is_big_endian ) {
        fout << "binary big_endian" << endl;
    } else {
        fout << "binary little_endian" << endl;
    }

    if( sizeof(SWIFT_Real) == sizeof(float) ) {
        fout << "real float" << endl;
    } else {
        fout << "real double" << endl;
    }

    fout << "vertices " << m->Num_Vertices() << endl;
    fout << "faces " << m->Num_Faces() << endl;
    fout << "map_vids " << m->Map_Vertex_Ids().Length() << endl;
    fout << "map_fids " << m->Map_Face_Ids().Length() << endl;
    fout << "pieces " << mfs.Length() << endl;

    // Compose the vertices into an array
    vs = new SWIFT_Real[m->Num_Vertices()*3];
    vs_walk = vs;
    for( i = 0; i < m->Num_Vertices(); i++, vs_walk += 3 ) {
        m->Vertices()[i].Coords().Get_Value( vs_walk );
    }

    // Write the vertices
    fout.write( (char*)vs, m->Num_Vertices()*3*sizeof(SWIFT_Real) );
    delete [] vs;

    // Compose the faces into an array
    fs = new int[m->Num_Faces()*3];
    for( i = 0, j = 0; i < m->Num_Faces(); i++, j += 3 ) {
        fs[j] = m->Vertex_Id( m->Faces()[i].Edge1().Origin() );
        fs[j+1] = m->Vertex_Id( m->Faces()[i].Edge2().Origin() );
        fs[j+2] = m->Vertex_Id( m->Faces()[i].Edge3().Origin() );
    }

    // Write out the faces
    fout.write( (char*)fs, m->Num_Faces()*3*sizeof(int) );
    delete [] fs;

    // Write out vertex mapping
    if( !m->No_Duplicate_Vertices() ) {
        fout.write( (char*)m->Map_Vertex_Ids().Data(),
                    m->Num_Vertices()*sizeof(int) );
    }

    // Write out face mapping
    if( !m->Only_Triangles() ) {
        fout.write( (char*)m->Map_Face_Ids().Data(),
                    m->Num_Faces()*sizeof(int) );
    }

    // Write out piece ids array
    fout.write( (char*)piece_ids.Data(), piece_ids.Length()*sizeof(int) );

    // Compose the original faces lengths into an array
    fs = new int[mfs.Length()];
    for( i = 0; i < mfs.Length(); i++ ) {
        fs[i] = mfs[i].Length();
    }

    // Write out the original faces lengths
    fout.write( (char*)fs, mfs.Length()*sizeof(int) );
    delete [] fs;
//.........这里部分代码省略.........

void Compute_Leaves( SWIFT_BV* piece )
{
    int i;

    if( piece == mesh->Root() ) {
        leaves.Destroy();
        leaves.Create( num_leaves );
        leaves.Set_Length( 0 );
    }

    if( piece->Is_Leaf() ) {
        leaves.Add( piece );
    } else {
        for( i = 0; i < piece->Num_Children(); i++ ) {
            Compute_Leaves( piece->Children()[i] );
        }
    }
}

void Compute_Piece_Centers_Of_Mass( )
{
    int i, j;
    SWIFT_Real area;
    SWIFT_Real total_area;
    SWIFT_Triple areav;
    SWIFT_Triple com;

    if( model_faces.Length() != 0 ) {
        piece_coms.Create( model_faces.Length() );
        for( i = 0; i < model_faces.Length(); i++ ) { 
            com.Set_Value( 0.0, 0.0, 0.0 );
            total_area = 0.0;
            for( j = 0; j < model_faces[i].Length(); j++ ) {
                areav = (mesh->Faces()[model_faces[i][j]].Edge1().Origin()->Coords() -
                         mesh->Faces()[model_faces[i][j]].Edge2().Origin()->Coords()) %
                        (mesh->Faces()[model_faces[i][j]].Edge1().Origin()->Coords() -
                         mesh->Faces()[model_faces[i][j]].Edge3().Origin()->Coords());
                area = 0.5 * areav.Length();
                total_area += area;
                com += area * (mesh->Faces()[model_faces[i][j]].Edge1().Origin()->Coords() +
                               mesh->Faces()[model_faces[i][j]].Edge2().Origin()->Coords() +
                               mesh->Faces()[model_faces[i][j]].Edge3().Origin()->Coords() );
            }
            for( j = 0; j < virtual_faces[i].Length(); j++ ) {
                areav = (virtual_faces[i][j].Edge1().Origin()->Coords() -
                        virtual_faces[i][j].Edge2().Origin()->Coords()) %
                        (virtual_faces[i][j].Edge1().Origin()->Coords() -
                        virtual_faces[i][j].Edge3().Origin()->Coords());
                area = 0.5 * areav.Length();
                total_area += area;
                com += area * (virtual_faces[i][j].Edge1().Origin()->Coords() +
                               virtual_faces[i][j].Edge2().Origin()->Coords() +
                               virtual_faces[i][j].Edge3().Origin()->Coords() );
            }

            piece_coms[i] = com / (3.0 * total_area);
        }
    }
}

void Convex_Initialize( SWIFT_Tri_Mesh* m )
{
    int i;
    Convex_Utilities_Initialize( m );

    // Store the mesh's twin info in the twin's list
    twins.Create( m->Num_Faces() );
    for( i = 0; i < m->Num_Faces(); i++ ) {
        twins[i][0] = m->Faces()[i].Edge1().Twin();
        twins[i][1] = m->Faces()[i].Edge2().Twin();
        twins[i][2] = m->Faces()[i].Edge3().Twin();
    }
}