TAPsConverter.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsConverter.cpp

Converter class is a static class.
See TAPsConverter.hpp for a detail description.

SUKITTI PUNAK   (04/22/2005)
UPDATE          (04/25/2005)
******************************************************************************/
#include "TAPsConverter.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T>
Point3<T> * Converter<T>::ConvertABezierPatchToAQuadMesh (  
    Point3<T> * bPts,           // i/p
    int uDegree, int vDegree,   // i/p
    int uSub, int vSub )        // i/p
{
    //----------------------------------------------------------------
    // Allocate memory for meshPts
    int mSize = ( uSub+1 ) * ( vSub+1 );
    Point3<T> * meshPts = new Point3<T>[ mSize ];
    if ( !meshPts ) return NULL;
    //----------------------------------------------------------------
    // Allocate memory for bPts
    int bSize = (uDegree + 1) * (vDegree + 1);
    Point3<T> * bPts1 = new Point3<T>[ bSize ];
    Point3<T> * bPts2 = new Point3<T>[ bSize ];
    if ( !bPts1 || !bPts2 ) {
        delete [] bPts1;
        delete [] bPts2;
        return NULL;
    }
    //if ( !bPts )  return NULL;
    //----------------------------------------------------------------
    T uStep = static_cast<T>(1.0) / static_cast<T>(uSub);
    T vStep = static_cast<T>(1.0) / static_cast<T>(vSub);
    T u = 0, v;
    for ( int i = 0; i <= uSub; ++i, u += uStep ) {
        v = 0;
        for ( int j = 0; j <= vSub; ++j, v += vStep ) {
            // Reset Bezier (control) points
            for ( int p = 0; p < bSize; ++p ) {
                bPts1[p] = bPts[p];
            }
            deCasteljauBiLinear( u, v, uDegree, vDegree, 
                    bPts1, bPts2, &meshPts[i*(vSub+1) + j] );
        }
    }
    delete [] bPts1;
    delete [] bPts2;
    return meshPts;
}
//-----------------------------------------------------------------------------
template <typename T>
void Converter<T>::deCasteljauBiLinear ( 
    T u, T v, int U, int V, // i/p
    Point3<T> * bPts_ip,    // i/o  bPts or control points
    Point3<T> * bPts_op,    // i/o
    Point3<T> * meshPt )    // o/p
{
    deCasteljauBiLinearRec( u, v, U, V, bPts_ip, bPts_op, meshPt );
}
//-----------------------------------------------------------------------------
template <typename T>
void Converter<T>::deCasteljauBiLinearRec( 
    T u, T v, int U, int V,     // i/p
    Point3<T> * bPts_ip,        // i/p
    Point3<T> * bPts_op,        // o/p
    Point3<T> * meshPt )        // o/p
{
    int inc = V + 1;
    T one = static_cast<T>( 1.0 );
    for ( int i = 0; i < U; ++i ) {
        for ( int j = 0; j < V; ++j ) {
            for ( int d = 0; d < 3; ++d ) {
                bPts_op[i*V + j][d] = (one-v)*(  (one-u)* bPts_ip[i*inc +j][d] 
                                                +     u * bPts_ip[(i+1)*inc +j][d] )
                                    +      v *(  (one-u)* bPts_ip[i*inc +j+1][d]
                                                +     u * bPts_ip[(i+1)*inc +j+1][d] );
            }
        }
    }
    //----------------------------------------------------------------
    if ( U == 1 && V == 1 ) {
        *meshPt = bPts_op[0];
    }
    //else if ( U == 0 || V == 0 ) deCasteljauCurve
    else    deCasteljauBiLinearRec( u, v, U-1, V-1, bPts_op, bPts_ip, meshPt ); // swap i/p and o/p
}
//-----------------------------------------------------------------------------
template <typename T>
bool Converter<T>::WriteGridPtsAsQuadMeshToA10FormatFile ( 
    Point3<T> * gridPts, int uSize, int vSize, char * outFileName )
{
    //----------------------------------------------------------------
    // Open the output file
    std::ofstream outFile ( outFileName, ios::out );
    if ( !outFile ) {
        std::cerr << "File could not be opened" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Write vertices
    outFile << uSize * vSize << "\n";       // write number of vertices
    int number = 0;
    for ( int u = 0; u < uSize; ++u ) { // write each vertex
        for ( int v = 0; v < vSize; ++v ) {
            outFile << ++number << "\t" 
                    << gridPts[ u*vSize + v ][0] << "\t"
                    << gridPts[ u*vSize + v ][1] << "\t"
                    << gridPts[ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write quad faces
    int vDeg = vSize - 1;
    outFile << (uSize-1) * vDeg << "\n";    // write number of faces
    for ( int u = 0; u < uSize-1; ++u ) {   // write each face
        for ( int v = 0; v < vSize-1; ++v ) {
            outFile << 4 << "\t" 
                    <<  u*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 2 << " "
                    <<  u*vSize + v + 2 << "\n";
        }
    }
    outFile.close();
    return true;
}
//-----------------------------------------------------------------------------
template <typename T>
bool Converter<T>::WriteGridPtsAsTriMeshToA10FormatFile ( 
    Point3<T> * gridPts, int uSize, int vSize, char * outFileName )
{
    std::ofstream outFile ( outFileName, ios::out );
    if ( !outFile ) {
        std::cerr << outFileName << " could not be opened!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Write vertices
    outFile << uSize * vSize << "\n";       // write number of vertices
    int number = 0;
    for ( int u = 0; u < uSize; ++u ) {     // write each vertex
        for ( int v = 0; v < vSize; ++v ) {
            outFile << ++number << "\t" 
                    << gridPts[ u*vSize + v ][0] << "\t"
                    << gridPts[ u*vSize + v ][1] << "\t"
                    << gridPts[ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces
    int vDeg = vSize - 1;
    outFile << (uSize-1) * vDeg * 2 << "\n";    // write number of faces
    for ( int u = 0; u < uSize-1; ++u ) {       // write each face
        for ( int v = 0; v < vSize-1; ++v ) {
            outFile << 3 << "\t" 
                    <<  u*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 2 << "\n";
            outFile << 3 << "\t" 
                    << (u+1)*vSize + v + 2 << " "
                    <<  u*vSize + v + 2 << " "
                    <<  u*vSize + v + 1 << "\n";
        }
    }
    outFile.close();
    return true;
}
//-----------------------------------------------------------------------------
template <typename T>
bool Converter<T>::WriteGridPtsAsTriMeshToA10FormatFile2 ( 
    Point3<T> * gridPts, int uSize, int vSize, char * outFileName )
{
    //----------------------------------------------------------------
    // Open the output file
    std::ofstream outFile ( outFileName, ios::out );
    if ( !outFile ) {
        std::cerr << outFileName << " could not be opened!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Write vertices
    int vDeg = vSize - 1;
    int noOfExtraVertices = (uSize-1) * vDeg;
    // write number of vertices
    outFile << uSize * vSize + noOfExtraVertices << "\n";
    int number = 0;
    // write each vertex
    for ( int u = 0; u < uSize; ++u ) {
        for ( int v = 0; v < vSize; ++v ) {
            outFile << ++number << "\t" 
                    << gridPts[ u*vSize + v ][0] << "\t"
                    << gridPts[ u*vSize + v ][1] << "\t"
                    << gridPts[ u*vSize + v ][2] << "\n";
        }
    }
    // write each extra vertex
    for ( int u = 0; u < uSize-1; ++u ) {
        for ( int v = 0; v < vSize-1; ++v ) {
            Vector3<T> vertex = (
                        gridPts[ u*vSize + v ]      +
                        gridPts[ (u+1)*vSize + v ]  +
                        gridPts[ (u+1)*vSize + v + 1 ]  +
                        gridPts[ u*vSize + v + 1 ]
                    ) / static_cast<T>(4);
            outFile << ++number << "\t" 
                    << vertex[0] << "\t"
                    << vertex[1] << "\t"
                    << vertex[2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces
    outFile << (uSize-1) * vDeg * 4 << "\n";    // write number of faces
    number = uSize*vSize + 1;
    for ( int u = 0; u < uSize-1; ++u ) {       // write each face
        for ( int v = 0; v < vSize-1; ++v, ++number ) {
            outFile << 3 << "\t" 
                    <<  u*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 1 << " "
                    <<  number << "\n";
            outFile << 3 << "\t" 
                    << (u+1)*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 2 << " "
                    <<  number << "\n";
            outFile << 3 << "\t" 
                    << (u+1)*vSize + v + 2 << " "
                    <<  u*vSize + v + 2 << " "
                    <<  number << "\n";
            outFile << 3 << "\t" 
                    <<  u*vSize + v + 2 << " "
                    <<  u*vSize + v + 1 << " "
                    <<  number << "\n";
        }
    }
    outFile.close();
    return true;
}
//-----------------------------------------------------------------------------
template <typename T>
Point3<T> * Converter<T>::ReadABezierPatchFromFile (
                char * inFileName,          // i/p
                int &uDeg, int &vDeg )      // o/p
{
    //----------------------------------------------------------------
    // Open the input file
    std::ifstream inFile ( inFileName, ios::in );
    if ( !inFile ) {
        std::cerr << inFileName << " could not be opened!" << std::endl;
        return NULL;
    }
    //----------------------------------------------------------------
    int type;
    inFile >> type;
    if ( type != 5 ) {
        std::cerr << inFileName << " does not contain a Bezier patch!" << std::endl;
    }
    inFile >> uDeg >> vDeg;
    //----------------------------------------------------------------
    Point3<T> * bPts = new Point3<T>[ (uDeg+1) * (vDeg+1) ];
    if ( !bPts )    return NULL;
    int index = 0;
    for ( int u = 0; u <= uDeg; ++u ) {
        for ( int v = 0; v <= vDeg; ++v, ++index ) {
            inFile >> bPts[index][0] >> bPts[index][1] >> bPts[index][2];
        }
    }
    inFile.close();
    return bPts;
}
//-----------------------------------------------------------------------------
// This function is for converting the Bezier patch hexoid into a 10 format hexoid
// the Bezier patch hexoid has 6 patches for six sides of the hexoid:
/*
        +---+
        | 5 |                 u and v indices
    +---+---+---+---+            +-u-->
    | 2 | 1 | 3 | 4 |            |
    +---+---+---+---+            v
        | 6 |
        +---+
*/

template <typename T>
bool Converter<T>::SpecialFnToCreateA10FormatFileFromHegDataFile ( int uSize, int vSize )
{
    //----------------------------------------------------------------
    // Open the input file
    std::ifstream inFile ( 
        "D:/Shared/MyWorksIII/TAPs/Applications/Data/HexDeg3.txt", 
        ios::in );
    if ( !inFile ) {
        std::cerr << "Input file could not be opened!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Open the output file
    std::ofstream outFile ( 
        "D:/Shared/MyWorksIII/TAPs/Applications/Data/HexDeg3Tri.10", 
        ios::out );
    if ( !outFile ) {
        std::cerr << "Output file could not be opened!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    int uDeg, vDeg;
    Point3<T> * bPts[6];
    Point3<T> * mPts[6];
    int type;
    //----------------------------------------------------------------
    for ( int i = 0; i < 6; ++i ) {
        inFile >> type;
        if ( type != 5 ) {
            std::cerr << "Input file does not contain a Bezier patch!" << std::endl;
        }
        inFile >> uDeg >> vDeg;
        //--------------------------------------------------
        bPts[i] = new Point3<T>[ (uDeg+1) * (vDeg+1) ];
        //--------------------------------------------------
        int index = 0;
        for ( int u = 0; u <= uDeg; ++u ) {
            for ( int v = 0; v <= vDeg; ++v, ++index ) {
                inFile >> bPts[i][index][0] >> bPts[i][index][1] >> bPts[i][index][2];
            }
        }
        mPts[i] = ConvertABezierPatchToAQuadMesh( bPts[i], uDeg, vDeg, uSize-1, vSize-1 );
    }
    inFile.close();

    
    //----------------------------------------------------------------
    // Write vertices
    int noOfVertices = uSize * vSize;           // patch# 1
    noOfVertices += 2 * uSize * (vSize-1);      // patch# 3 & 4
    noOfVertices += uSize * (vSize-2);          // patch# 2
    noOfVertices += 2 * (uSize-2) * (vSize-2);  // patch# 5 & 6
    int number = 0, number1 = 0;
    outFile << noOfVertices << "\n";    // write number of vertices
    //----------------------------------------------------------------
    // Write each vertex of patch# 1
    for ( int u = 0; u < uSize; ++u ) {
        for ( int v = 0; v < vSize; ++v ) {
            outFile << setiosflags( ios::fixed | ios::showpoint )
                    << ++number << "\t" 
                    << mPts[0][ u*vSize + v ][0] << setprecision( 6 ) << " "
                    << mPts[0][ u*vSize + v ][1] << " "
                    << mPts[0][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write each vertex of patch# 3
    for ( int u = 0; u < uSize; ++u ) {
        for ( int v = 1; v < vSize; ++v ) {
            outFile << ++number << "\t" 
                    << mPts[2][ u*vSize + v ][0] << " "
                    << mPts[2][ u*vSize + v ][1] << " "
                    << mPts[2][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write each vertex of patch# 4
    for ( int u = 0; u < uSize; ++u ) {
        for ( int v = 1; v < vSize; ++v ) {
            outFile << ++number << "\t" 
                    << mPts[3][ u*vSize + v ][0] << " "
                    << mPts[3][ u*vSize + v ][1] << " "
                    << mPts[3][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write each vertex of patch# 2
    for ( int u = 0; u < uSize; ++u ) {
        for ( int v = 1; v < vSize-1; ++v ) {
            outFile << ++number << "\t" 
                    << mPts[1][ u*vSize + v ][0] << " "
                    << mPts[1][ u*vSize + v ][1] << " "
                    << mPts[1][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write each vertex of patch# 5
    for ( int u = 1; u < uSize-1; ++u ) {
        for ( int v = 1; v < vSize-1; ++v ) {
            outFile << ++number << "\t" 
                    << mPts[4][ u*vSize + v ][0] << " "
                    << mPts[4][ u*vSize + v ][1] << " "
                    << mPts[4][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write each vertex of patch# 6
    for ( int u = 1; u < uSize-1; ++u ) {
        for ( int v = 1; v < vSize-1; ++v ) {
            outFile << ++number << "\t" 
                    << mPts[5][ u*vSize + v ][0] << " "
                    << mPts[5][ u*vSize + v ][1] << " "
                    << mPts[5][ u*vSize + v ][2] << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 1)
    int inc, inc1;
    int noOfFaces = 10 * (uSize-1) * (vSize-1);
    noOfFaces += 2 * (uSize-3) * (uSize-3);
    noOfFaces += 2 * (uSize-3);
    noOfFaces += 2 * (uSize-3);
    noOfFaces += 2 * (uSize-3);
    noOfFaces += 2 * (uSize-3);
    noOfFaces += 8;
    outFile << noOfFaces << "\n";   // write number of faces
    for ( int u = 0; u < uSize-1; ++u ) {       // write each face
        for ( int v = 0; v < vSize-1; ++v ) {
            outFile << 3 << "  " 
                    <<  u*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 1 << " "
                    << (u+1)*vSize + v + 2 << "\n";
            outFile << 3 << "  " 
                    << (u+1)*vSize + v + 2 << " "
                    <<  u*vSize + v + 2 << " "
                    <<  u*vSize + v + 1 << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 3)
    number = uSize * vSize; // after patch# 1
    inc = vSize - 1;
    // Write faces
    for ( int u = 0; u < uSize-1; ++u ) {
        outFile << 3 << "\t" 
                <<  u*vSize + vSize << " "
                << (u+1)*vSize + vSize << " "
                << number + (u+1)*inc + 1 << "\n";
        outFile << 3 << "\t" 
                << number + (u+1)*inc + 1 << " "
                << number +  u*inc + 1 << " "
                << u*vSize + vSize << "\n";
    }
    // Write faces of patch#3 connected with patch#1
    for ( int u = 0; u < uSize-1; ++u ) {
        for ( int v = 1; v < inc; ++v ) {
            outFile << 3 << "\t" 
                    << number + u*inc + v << " "
                    << number + (u+1)*inc + v << " "
                    << number + (u+1)*inc + v + 1 << "\n";
            outFile << 3 << "\t" 
                    << number + (u+1)*inc + v + 1 << " "
                    << number +  u*inc + v + 1 << " "
                    << number +  u*inc + v << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 4)
    number = uSize * vSize;                 // after patch# 1
    number1 = number + uSize * (vSize-1);   // after patch# 1 and 3
    inc = vSize - 1;
    // Write faces
    for ( int u = 0; u < uSize-1; ++u ) {
        outFile << 3 << "\t" 
                << number + u*inc + inc << " "
                << number + (u+1)*inc + inc << " "
                << number1 + (u+1)*inc + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + (u+1)*inc + 1 << " "
                << number1 +  u*inc + 1 << " "
                << number + u*inc + inc << "\n";
    }
    // Write faces of patch#4 connected with patch#3
    for ( int u = 0; u < uSize-1; ++u ) {
        for ( int v = 1; v < inc; ++v ) {
            outFile << 3 << "\t" 
                    << number1 + u*inc + v << " "
                    << number1 + (u+1)*inc + v << " "
                    << number1 + (u+1)*inc + v + 1 << "\n";
            outFile << 3 << "\t" 
                    << number1 + (u+1)*inc + v + 1 << " "
                    << number1 +  u*inc + v + 1 << " "
                    << number1 +  u*inc + v << "\n";
        }
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 2)
    number = number1;                       // after patch# 1 and 3
    number1 = number + uSize * (vSize-1);   // after patch# 1, 3, and 4
    inc  = vSize - 1;
    inc1 = inc - 1;
    // Write faces
    for ( int u = 0; u < uSize-1; ++u ) {
        for ( int v = 1; v < inc1; ++v ) {
            outFile << 3 << "\t" 
                    << number1 + u*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v + 1 << "\n";
            outFile << 3 << "\t" 
                    << number1 + (u+1)*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v << "\n";
        }
    }
    // Write faces of patch#2 connected with patch#4
    for ( int u = 0; u < uSize-1; ++u ) {
        outFile << 3 << "\t" 
                << number + u*inc + inc << " "
                << number + (u+1)*inc + inc << " "
                << number1 + (u+1)*inc1 + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + (u+1)*inc1 + 1 << " "
                << number1 +  u*inc1 + 1 << " "
                << number + u*inc + inc << "\n";
    }
    // Write faces of patch#2 connected with patch#1
    for ( int u = 0; u < uSize-1; ++u ) {
        outFile << 3 << "\t" 
                << number1 +  u*inc1 + inc1 << " "
                << number1 + (u+1)*inc1 + inc1 << " "
                << (u+1)*vSize + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + u*inc1 + inc1 << " "
                << (u+1)*vSize + 1 << " "
                << u*vSize + 1 << "\n";
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 5)
    number = number1;                       // after patch# 1, 3, and 4
    number1 = number + uSize * (vSize-2);   // after patch# 1, 3, 4, and 2
    inc  = vSize - 1;
    inc1 = inc - 1;
    // Write faces
    for ( int u = 0; u < uSize-3; ++u ) {
        for ( int v = 1; v < inc1; ++v ) {
            outFile << 3 << "\t" 
                    << number1 + u*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v + 1 << "\n";
            outFile << 3 << "\t" 
                    << number1 + (u+1)*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v << "\n";
        }
    }
    // Write faces of patch#5 connected with patch#1
    --inc1;
    for ( int v = 1; v < vSize-2; ++v ) {
        outFile << 3 << "\t" 
                << number1 +  (uSize-2)*inc1 + v << " "
                << v + 1 << " "
                << v + 2 << "\n";
        outFile << 3 << "\t" 
                << v + 2 << " " 
                << number1 +  (uSize-2)*inc1 + v + 1 << " " 
                << number1 +  (uSize-2)*inc1 + v << "\n";
    }
    // Write faces of patch#5 connected with patch#3
    number = uSize * vSize;     // vertex after patch#1
    ++inc1;
    for ( int u = 0; u < uSize-3; ++u ) {
        int op = vSize - 3 - u;
        outFile << 3 << "\t" 
                << number1 +  (uSize-2)*u + inc1 << " "
                << number1 +  (uSize-2)*(u+1) + inc1 << " "
                << number + op << "\n";
        outFile << 3 << "\t" 
                << number + op << " "
                << number + op + 1 << " "
                << number1 +  (uSize-2)*u + inc1 << "\n";
    }
    // Write faces of patch#5 connected with patch#4
    number = uSize * (vSize + (vSize-1));   // vertex after patch# 1 and 3
    for ( int v = 1; v < vSize-2; ++v ) {
        int op = vSize - 1 - v;
        outFile << 3 << "\t" 
                << number + op << " "
                << number1 +  v << " "
                << number1 +  v + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 +  v + 1 << " "
                << number + op - 1 << " "
                << number + op << "\n";
    }
    // Write faces of patch#5 connected with patch#2
    number = uSize * (vSize + (vSize-1)*2); // vertex after patch#1, 3, and 4
    for ( int u = 1; u < uSize-2; ++u ) {
        outFile << 3 << "\t" 
                << number1 + (uSize-2)*u + 1 << " "
                << number +  u << " "
                << number +  u + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + (uSize-2)*u + 1 << " "
                << number1 + (uSize-2)*(u-1) + 1 << " "
                << number +  u << "\n";
    }
    // Write cornors of patch#5
    {
        //----------------------------------------
        // Bottom left
        //number = uSize * (vSize + (vSize-1)*2);   // vertex after patch#1, 3, and 4
        int v1 = number + vSize - 2;
        int v2 = 1;
        int v3 = 2;
        int v4 = number1 + (uSize-2)*(vSize-3) + 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Bottom right
        v1 = number1 + (uSize-2)*(vSize-2);
        v2 = vSize - 1;
        v3 = vSize;
        v4 = uSize*vSize + 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Top left
        v1 = uSize * (vSize + (vSize-1)) + vSize - 1;
        v2 = uSize * (vSize + (vSize-1)*2) + 1;
        v3 = number1 + 1;
        v4 = v1 - 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Top right
        v1 = uSize * (vSize + (vSize-1)) + 1;
        v2 = number1 + vSize - 2;
        v3 = uSize*vSize + vSize - 2;
        v4 = uSize*vSize + vSize - 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
    }
    //----------------------------------------------------------------
    // Write triangle faces (patch# 6)
    number = uSize * (vSize + (vSize-1)*2 + (vSize-2)); // after patch# 1, 3, 4, and 2
    number1 = number + (uSize-2)*(vSize-2); // after patch# 1, 3, 4, 2, and 5
    inc  = vSize - 1;
    inc1 = inc - 1;
    // Write faces
    for ( int u = 0; u < uSize-3; ++u ) {
        for ( int v = 1; v < inc1; ++v ) {
            outFile << 3 << "\t" 
                    << number1 + u*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v << " "
                    << number1 + (u+1)*inc1 + v + 1 << "\n";
            outFile << 3 << "\t" 
                    << number1 + (u+1)*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v + 1 << " "
                    << number1 +  u*inc1 + v << "\n";
        }
    }
    // Write faces of patch#6 connected with patch#1
    for ( int v = 1; v < vSize-2; ++v ) {
        outFile << 3 << "\t" 
                << uSize*(vSize-1) + v + 1 << " "
                << number1 + v << " "
                << number1 + v + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + v + 1 << " "
                << uSize*(vSize-1) + v + 2 << " "
                << uSize*(vSize-1) + v + 1 << "\n";
    }
    // Write faces of patch#6 connected with patch#3
    number = uSize * vSize + (uSize-1)*(vSize-1) + 2;   // vertex after patch#1 + some of patch#3
    for ( int u = 0; u < uSize-3; ++u ) {
        outFile << 3 << "\t" 
                << number1 +  (uSize-2)*u + inc1 << " "
                << number1 +  (uSize-2)*(u+1) + inc1 << " "
                << number + u << "\n";
        outFile << 3 << "\t" 
                << number + u << " "
                << number + u - 1 << " "
                << number1 +  (uSize-2)*u + inc1 << "\n";
    }
    // Write faces of patch#6 connected with patch#4
    number = uSize * (vSize + (vSize-1));   // vertex after patch#1 and 3
    number += (uSize-1)*(vSize-1);          // and some of patch#4
    for ( int v = 1; v < vSize-2; ++v ) {
        int op = vSize - v - 2;
        outFile << 3 << "\t" 
                << number1 + (uSize-2)*(vSize-3) + v << " "
                << number + op + 1 << " "
                << number + op << "\n";     
        outFile << 3 << "\t" 
                << number + op << " "
                << number1 + (uSize-2)*(vSize-3) + v + 1<< " "
                << number1 + (uSize-2)*(vSize-3) + v << "\n";
    }
    // Write faces of patch#6 connected with patch#2
    number = uSize * (vSize + (vSize-1)*2); // vertex after patch#1, 3, and 4
    number += (uSize)*(vSize-3);            // and some of patch#2
    for ( int u = 0; u < uSize-3; ++u ) {
        int op = vSize - u;
        outFile << 3 << "\t" 
                << number +  op << " "
                << number +  op - 1 << " "
                << number1 + (u+1)*(vSize-2) + 1 << "\n";
        outFile << 3 << "\t" 
                << number1 + (u+1)*(vSize-2) + 1 << " "
                << number1 + (u)*(vSize-2) + 1 << " "
                << number +  op << "\n";
    }
    // Write cornors of patch#6
    {
        //----------------------------------------
        // Top left
        number = (uSize-1) * (vSize);
        int v1 = number + 1;
        int v2 = uSize * (vSize + (vSize-1)*2) + uSize*(vSize-2);
        int v3 = number1 + 1;
        int v4 = number + 2;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Top right
        number = (uSize) * (vSize);
        v1 = number - 1;
        v2 = number1 + vSize - 2;
        v3 = uSize*vSize + (uSize-1)*(vSize-1) + 1;
        v4 = uSize * vSize;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Bottom left
        number = uSize * (vSize + (vSize-1)) + (uSize)*(vSize-1);
        v1 = uSize * (vSize + (vSize-1)*2) + (uSize-1)*(vSize-2) + 1;
        v2 = number;
        v3 = number - 1;
        v4 = number1 + (uSize-2)*(vSize-3) + 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
        //----------------------------------------
        // Bottom right
        number = uSize*vSize + (uSize)*(vSize-1);
        v1 = number1 + (uSize-2)*(vSize-2);
        v2 = uSize * (vSize + (vSize-1)) + (uSize-1)*(vSize-1) + 1;
        v3 = number;
        v4 = number - 1;
        outFile << 3 << "\t" << v1 << " " << v2 << " " << v3 << "\n";
        outFile << 3 << "\t" << v3 << " " << v4 << " " << v1 << "\n";
    }
    //----------------------------------------------------------------
    for ( int i = 0; i < 6; ++i ) {
        delete [] bPts[i];
        delete [] mPts[i];
    }
    outFile.close();
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8