vrml_layer.cpp

Go to the documentation of this file.

/*
 * file: vrml_layer.cpp
 *
 * This program source code file is part of KiCad, a free EDA CAD application.
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Copyright (C) 2013-2017  Cirilo Bernardo
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
// Wishlist:
// 1. crop anything outside the board outline on PTH, silk, and copper layers
// 2. on the PTH layer, handle cropped holes differently from others;
//    these are assumed to be castellated edges and the profile is not
//    a closed loop as assumed for all other outlines.
// 3. a scheme is needed to tell a castellated edge from a plain board edge
 
#include <kicad_gl/kiglu.h>
 
#include <sstream>
#include <string>
#include <iomanip>
#include <cmath>
#include <io/idf/vrml_layer.h>
#include <trigo.h>
 
#ifndef CALLBACK
#define CALLBACK
#endif
 
#define GLCALLBACK(x) (( void (CALLBACK*)() )&(x))
 
// minimum sides to a circle
#define MIN_NSIDES 6
 
static void FormatDoublet( double x, double y, int precision, std::string& strx, std::string& stry )
{
    std::ostringstream ostr;
 
    ostr << std::fixed << std::setprecision( precision );
 
    ostr << x;
    strx = ostr.str();
 
    ostr.str( "" );
    ostr << y;
    stry = ostr.str();
 
    while( *strx.rbegin() == '0' )
        strx.erase( strx.size() - 1 );
 
    while( *stry.rbegin() == '0' )
        stry.erase( stry.size() - 1 );
}
 
 
static void FormatSinglet( double x, int precision, std::string& strx )
{
    std::ostringstream ostr;
 
    ostr << std::fixed << std::setprecision( precision );
 
    ostr << x;
    strx = ostr.str();
 
    while( *strx.rbegin() == '0' )
        strx.erase( strx.size() - 1 );
}
 
 
int VRML_LAYER::calcNSides( double aRadius, double aAngle )
{
    // check #segments on ends of arc
    int maxSeg = maxArcSeg * aAngle / M_PI;
 
    if( maxSeg < 3 )
        maxSeg = 3;
 
    int csides = aRadius * M_PI / minSegLength;
 
    if( csides < 0 )
        csides = -csides;
 
    if( csides > maxSeg )
    {
        if( csides < 2 * maxSeg )
            csides /= 2;
        else
            csides = ( ( (double) csides ) * minSegLength / maxSegLength );
    }
 
    if( csides < 3 )
        csides = 3;
 
    if( ( csides & 1 ) == 0 )
        csides += 1;
 
    return csides;
}
 
 
static void CALLBACK vrml_tess_begin( GLenum cmd, void* user_data )
{
    VRML_LAYER* lp = (VRML_LAYER*) user_data;
 
    lp->glStart( cmd );
}
 
 
static void CALLBACK vrml_tess_end( void* user_data )
{
    VRML_LAYER* lp = (VRML_LAYER*) user_data;
 
    lp->glEnd();
}
 
 
static void CALLBACK vrml_tess_vertex( void* vertex_data, void* user_data )
{
    VRML_LAYER* lp = (VRML_LAYER*) user_data;
 
    lp->glPushVertex( (VERTEX_3D*) vertex_data );
}
 
 
static void CALLBACK vrml_tess_err( GLenum errorID, void* user_data )
{
    VRML_LAYER* lp = (VRML_LAYER*) user_data;
 
    lp->Fault = true;
    lp->SetGLError( errorID );
}
 
 
static void CALLBACK vrml_tess_combine( GLdouble coords[3], VERTEX_3D* vertex_data[4],
                                        GLfloat weight[4], void** outData, void* user_data )
{
    VRML_LAYER* lp = (VRML_LAYER*) user_data;
 
    // the plating is set to true only if all are plated
    bool plated = vertex_data[0]->pth;
 
    if( !vertex_data[1]->pth )
        plated = false;
 
    if( vertex_data[2] && !vertex_data[2]->pth )
        plated = false;
 
    if( vertex_data[3] && !vertex_data[3]->pth )
        plated = false;
 
    *outData = lp->AddExtraVertex( coords[0], coords[1], plated );
}
 
 
VRML_LAYER::VRML_LAYER()
{
    ResetArcParams();
    offsetX = 0.0;
    offsetY = 0.0;
 
    fix = false;
    Fault = false;
    idx = 0;
    hidx = 0;
    eidx = 0;
    ord = 0;
    glcmd   = 0;
    pholes  = NULL;
 
    tess = gluNewTess();
 
    if( !tess )
        return;
 
    // set up the tesselator callbacks
    gluTessCallback( tess, GLU_TESS_BEGIN_DATA, GLCALLBACK( vrml_tess_begin ) );
 
    gluTessCallback( tess, GLU_TESS_VERTEX_DATA, GLCALLBACK( vrml_tess_vertex ) );
 
    gluTessCallback( tess, GLU_TESS_END_DATA, GLCALLBACK( vrml_tess_end ) );
 
    gluTessCallback( tess, GLU_TESS_ERROR_DATA, GLCALLBACK( vrml_tess_err ) );
 
    gluTessCallback( tess, GLU_TESS_COMBINE_DATA, GLCALLBACK( vrml_tess_combine ) );
 
    gluTessProperty( tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
 
    gluTessNormal( tess, 0, 0, 1 );
}
 
 
VRML_LAYER::~VRML_LAYER()
{
    Clear();
 
    if( tess )
    {
        gluDeleteTess( tess );
        tess = NULL;
    }
}
 
 
void VRML_LAYER::ResetArcParams()
{
    // arc parameters suitable to mm measurements
    maxArcSeg = 48;
    minSegLength = 0.1;
    maxSegLength = 0.5;
}
 
 
void VRML_LAYER::GetArcParams( int& aMaxSeg, double& aMinLength, double& aMaxLength )
{
    aMaxSeg = maxArcSeg;
    aMinLength = minSegLength;
    aMaxLength = maxSegLength;
}
 
 
bool VRML_LAYER::SetArcParams( int aMaxSeg, double aMinLength, double aMaxLength )
{
    if( aMaxSeg < 8 )
        aMaxSeg = 8;
 
    if( aMinLength <= 0 || aMaxLength <= aMinLength )
        return false;
 
    maxArcSeg = aMaxSeg;
    minSegLength = aMinLength;
    maxSegLength = aMaxLength;
    return true;
}
 
 
void VRML_LAYER::Clear( void )
{
    int i;
 
    fix = false;
    idx = 0;
 
    for( i = contours.size(); i > 0; --i )
    {
        delete contours.back();
        contours.pop_back();
    }
 
    pth.clear();
 
    areas.clear();
 
    for( i = vertices.size(); i > 0; --i )
    {
        delete vertices.back();
        vertices.pop_back();
    }
 
    clearTmp();
}
 
 
void VRML_LAYER::clearTmp( void )
{
    unsigned int i;
 
    Fault   = false;
    hidx    = 0;
    eidx    = 0;
    ord = 0;
    glcmd = 0;
 
    triplets.clear();
    solid.clear();
 
    for( i = outline.size(); i > 0; --i )
    {
        delete outline.back();
        outline.pop_back();
    }
 
    ordmap.clear();
 
    for( i = extra_verts.size(); i > 0; --i )
    {
        delete extra_verts.back();
        extra_verts.pop_back();
    }
 
    // note: unlike outline and extra_verts,
    // vlist is not responsible for memory management
    vlist.clear();
 
    // go through the vertex list and reset ephemeral parameters
    for( i = 0; i < vertices.size(); ++i )
    {
        vertices[i]->o = -1;
    }
}
 
 
int VRML_LAYER::NewContour( bool aPlatedHole )
{
    if( fix )
        return -1;
 
    std::list<int>* contour = new std::list<int>;
 
    contours.push_back( contour );
    areas.push_back( 0.0 );
 
    pth.push_back( aPlatedHole );
 
    return contours.size() - 1;
}
 
 
bool VRML_LAYER::AddVertex( int aContourID, double aXpos, double aYpos )
{
    if( fix )
    {
        error = "AddVertex(): no more vertices may be added (Tesselate was previously executed)";
        return false;
    }
 
    if( aContourID < 0 || (unsigned int) aContourID >= contours.size() )
    {
        error = "AddVertex(): aContour is not within a valid range";
        return false;
    }
 
    VERTEX_3D* vertex = new VERTEX_3D;
    vertex->x   = aXpos;
    vertex->y   = aYpos;
    vertex->i   = idx++;
    vertex->o   = -1;
    vertex->pth = pth[ aContourID ];
 
    VERTEX_3D* v2 = NULL;
 
    if( contours[aContourID]->size() > 0 )
        v2 = vertices[ contours[aContourID]->back() ];
 
    vertices.push_back( vertex );
    contours[aContourID]->push_back( vertex->i );
 
    if( v2 )
        areas[aContourID] += ( aXpos - v2->x ) * ( aYpos + v2->y );
 
    return true;
}
 
 
bool VRML_LAYER::EnsureWinding( int aContourID, bool aHoleFlag )
{
    if( aContourID < 0 || (unsigned int) aContourID >= contours.size() )
    {
        error = "EnsureWinding(): aContour is outside the valid range";
        return false;
    }
 
    std::list<int>* cp = contours[aContourID];
 
    if( cp->size() < 3 )
    {
        error = "EnsureWinding(): there are fewer than 3 vertices";
        return false;
    }
 
    double dir = areas[aContourID];
 
    VERTEX_3D* vp0 = vertices[ cp->back() ];
    VERTEX_3D* vp1 = vertices[ cp->front() ];
 
    dir += ( vp1->x - vp0->x ) * ( vp1->y + vp0->y );
 
    // if dir is positive, winding is CW
    if( ( aHoleFlag && dir < 0 ) || ( !aHoleFlag && dir > 0 ) )
    {
        cp->reverse();
        areas[aContourID] = -areas[aContourID];
    }
 
    return true;
}
 
 
bool VRML_LAYER::AppendCircle( double aXpos, double aYpos, double aRadius, int aContourID,
                               bool aHoleFlag )
{
    if( aContourID < 0 || (unsigned int) aContourID >= contours.size() )
    {
        error = "AppendCircle(): invalid contour (out of range)";
        return false;
    }
 
    int nsides = M_PI * 2.0 * aRadius / minSegLength;
 
    if( nsides > maxArcSeg )
    {
        if( nsides > 2 * maxArcSeg )
        {
            // use segments approx. maxAr
            nsides = M_PI * 2.0 * aRadius / maxSegLength;
        }
        else
        {
            nsides /= 2;
        }
    }
 
    if( nsides < MIN_NSIDES )
        nsides = MIN_NSIDES;
 
    // even numbers give prettier results for circles
    if( nsides & 1 )
        nsides += 1;
 
    double da = M_PI * 2.0 / nsides;
 
    bool fail = false;
 
    if( aHoleFlag )
    {
        fail |= !AddVertex( aContourID, aXpos + aRadius, aYpos );
 
        for( double angle = da; angle < M_PI * 2; angle += da )
        {
            fail |= !AddVertex( aContourID, aXpos + aRadius * cos( angle ),
                                            aYpos - aRadius * sin( angle ) );
        }
    }
    else
    {
        fail |= !AddVertex( aContourID, aXpos + aRadius, aYpos );
 
        for( double angle = da; angle < M_PI * 2; angle += da )
        {
            fail |= !AddVertex( aContourID, aXpos + aRadius * cos( angle ),
                                            aYpos + aRadius * sin( angle ) );
        }
    }
 
    return !fail;
}
 
 
bool VRML_LAYER::AddCircle( double aXpos, double aYpos, double aRadius, bool aHoleFlag,
                            bool aPlatedHole )
{
    int pad;
 
    if( aHoleFlag && aPlatedHole )
        pad = NewContour( true );
    else
        pad = NewContour( false );
 
    if( pad < 0 )
    {
        error = "AddCircle(): failed to add a contour";
        return false;
    }
 
    return AppendCircle( aXpos, aYpos, aRadius, pad, aHoleFlag );
}
 
 
bool VRML_LAYER::AddSlot( double aCenterX, double aCenterY, double aSlotLength, double aSlotWidth,
                          double aAngle, bool aHoleFlag, bool aPlatedHole )
{
    aAngle *= M_PI / 180.0;
 
    if( aSlotWidth > aSlotLength )
    {
        aAngle += M_PI2;
        std::swap( aSlotLength, aSlotWidth );
    }
 
    aSlotWidth /= 2.0;
    aSlotLength = aSlotLength / 2.0 - aSlotWidth;
 
    int csides = calcNSides( aSlotWidth, M_PI );
 
    double capx, capy;
 
    capx    = aCenterX + cos( aAngle ) * aSlotLength;
    capy    = aCenterY + sin( aAngle ) * aSlotLength;
 
    double ang, da;
    int i;
    int pad;
 
    if( aHoleFlag && aPlatedHole )
        pad = NewContour( true );
    else
        pad = NewContour( false );
 
    if( pad < 0 )
    {
        error = "AddCircle(): failed to add a contour";
        return false;
    }
 
    da = M_PI / csides;
    bool fail = false;
 
    if( aHoleFlag )
    {
        for( ang = aAngle + M_PI2, i = 0; i < csides; ang -= da, ++i )
            fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                                capy + aSlotWidth * sin( ang ) );
 
        ang = aAngle - M_PI2;
        fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                            capy + aSlotWidth * sin( ang ) );
 
        capx    = aCenterX - cos( aAngle ) * aSlotLength;
        capy    = aCenterY - sin( aAngle ) * aSlotLength;
 
        for( ang = aAngle - M_PI2, i = 0; i < csides; ang -= da, ++i )
            fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                                capy + aSlotWidth * sin( ang ) );
 
        ang = aAngle + M_PI2;
        fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                            capy + aSlotWidth * sin( ang ) );
    }
    else
    {
        for( ang = aAngle - M_PI2, i = 0; i < csides; ang += da, ++i )
            fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                                capy + aSlotWidth * sin( ang ) );
 
        ang = aAngle + M_PI2;
        fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                            capy + aSlotWidth * sin( ang ) );
 
        capx    = aCenterX - cos( aAngle ) * aSlotLength;
        capy    = aCenterY - sin( aAngle ) * aSlotLength;
 
        for( ang = aAngle + M_PI2, i = 0; i < csides; ang += da, ++i )
            fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                                capy + aSlotWidth * sin( ang ) );
 
        ang = aAngle - M_PI2;
        fail |= !AddVertex( pad, capx + aSlotWidth * cos( ang ),
                            capy + aSlotWidth * sin( ang ) );
    }
 
    return !fail;
}
 
 
bool VRML_LAYER::AddPolygon( const std::vector< wxRealPoint >& aPolySet, double aCenterX,
                             double aCenterY, double aAngle )
{
    int pad = NewContour( false );
 
    if( pad < 0 )
    {
        error = "AddPolygon(): failed to add a contour";
        return false;
    }
 
    for( auto corner : aPolySet )
    {
        // The sense of polygon rotations is reversed
        RotatePoint( &corner.x, &corner.y, -EDA_ANGLE( aAngle, DEGREES_T ) );
        AddVertex( pad, aCenterX + corner.x, aCenterY + corner.y );
    }
 
    if( !EnsureWinding( pad, false ) )
        return false;
 
    return true;
}
 
 
// adds an arc to the given center, start point, pen width, and angle (degrees).
bool VRML_LAYER::AppendArc( double aCenterX, double aCenterY, double aRadius,
                            double aStartAngle, double aAngle, int aContourID )
{
    if( aContourID < 0 || (unsigned int) aContourID >= contours.size() )
    {
        error = "AppendArc(): invalid contour (out of range)";
        return false;
    }
 
    aAngle = aAngle / 180.0 * M_PI;
    aStartAngle = aStartAngle / 180.0 * M_PI;
 
    int nsides = calcNSides( aRadius, aAngle );
 
    double da = aAngle / nsides;
 
    bool fail = false;
 
    if( aAngle > 0 )
    {
        aAngle += aStartAngle;
 
        for( double ang = aStartAngle; ang < aAngle; ang += da )
        {
            fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),
                                            aCenterY + aRadius * sin( ang ) );
        }
    }
    else
    {
        aAngle += aStartAngle;
 
        for( double ang = aStartAngle; ang > aAngle; ang += da )
        {
            fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),
                                            aCenterY + aRadius * sin( ang ) );
        }
    }
 
    return !fail;
}
 
 
bool VRML_LAYER::AddArc( double aCenterX, double aCenterY, double aStartX, double aStartY,
                         double aArcWidth, double aAngle, bool aHoleFlag, bool aPlatedHole )
{
    aAngle *= M_PI / 180.0;
 
    // we don't accept small angles; in fact, 1 degree ( 0.01745 ) is already
    // way too small but we must set a limit somewhere
    if( aAngle < 0.01745 && aAngle > -0.01745 )
    {
        error = "AddArc(): angle is too small: abs( angle ) < 1 degree";
        return false;
    }
 
    double rad = sqrt( (aStartX - aCenterX) * (aStartX - aCenterX)
                        + (aStartY - aCenterY) * (aStartY - aCenterY) );
 
    aArcWidth /= 2.0;    // this is the radius of the caps
 
    // we will not accept an arc with an inner radius close to zero so we
    // set a limit here. the end result will vary somewhat depending on
    // the output units
    if( aArcWidth >= ( rad * 1.01 ) )
    {
        error = "AddArc(): width/2 exceeds radius*1.01";
        return false;
    }
 
    // calculate the radii of the outer and inner arcs
    double  orad    = rad + aArcWidth;
    double  irad    = rad - aArcWidth;
 
    int osides  = calcNSides( orad, aAngle );
    int isides  = calcNSides( irad, aAngle );
    int csides  = calcNSides( aArcWidth, M_PI );
 
    double  stAngle     = atan2( aStartY - aCenterY, aStartX - aCenterX );
    double  endAngle    = stAngle + aAngle;
 
    // calculate ends of inner and outer arc
    double  oendx   = aCenterX + orad* cos( endAngle );
    double  oendy   = aCenterY + orad* sin( endAngle );
    double  ostx    = aCenterX + orad* cos( stAngle );
    double  osty    = aCenterY + orad* sin( stAngle );
 
    double  iendx   = aCenterX + irad* cos( endAngle );
    double  iendy   = aCenterY + irad* sin( endAngle );
    double  istx    = aCenterX + irad* cos( stAngle );
    double  isty    = aCenterY + irad* sin( stAngle );
 
    if( ( aAngle < 0 && !aHoleFlag ) || ( aAngle > 0 && aHoleFlag ) )
    {
        aAngle = -aAngle;
        std::swap( stAngle, endAngle );
        std::swap( oendx, ostx );
        std::swap( oendy, osty );
        std::swap( iendx, istx );
        std::swap( iendy, isty );
    }
 
    int arc;
 
    if( aHoleFlag && aPlatedHole )
        arc = NewContour( true );
    else
        arc = NewContour( false );
 
    if( arc < 0 )
    {
        error = "AddArc(): could not create a contour";
        return false;
    }
 
    // trace the outer arc:
    int i;
    double  ang;
    double  da = aAngle / osides;
 
    for( ang = stAngle, i = 0; i < osides; ang += da, ++i )
        AddVertex( arc, aCenterX + orad * cos( ang ), aCenterY + orad * sin( ang ) );
 
    // trace the first cap
    double  capx    = ( iendx + oendx ) / 2.0;
    double  capy    = ( iendy + oendy ) / 2.0;
 
    if( aHoleFlag )
        da = -M_PI / csides;
    else
        da = M_PI / csides;
 
    for( ang = endAngle, i = 0; i < csides; ang += da, ++i )
        AddVertex( arc, capx + aArcWidth * cos( ang ), capy + aArcWidth * sin( ang ) );
 
    // trace the inner arc:
    da = -aAngle / isides;
 
    for( ang = endAngle, i = 0; i < isides; ang += da, ++i )
        AddVertex( arc, aCenterX + irad * cos( ang ), aCenterY + irad * sin( ang ) );
 
    // trace the final cap
    capx    = ( istx + ostx ) / 2.0;
    capy    = ( isty + osty ) / 2.0;
 
    if( aHoleFlag )
        da = -M_PI / csides;
    else
        da = M_PI / csides;
 
    for( ang = stAngle + M_PI, i = 0; i < csides; ang += da, ++i )
        AddVertex( arc, capx + aArcWidth * cos( ang ), capy + aArcWidth * sin( ang ) );
 
    return true;
}
 
 
bool VRML_LAYER::Tesselate( VRML_LAYER* holes, bool aHolesOnly )
{
    if( !tess )
    {
        error = "Tesselate(): GLU tesselator was not initialized";
        return false;
    }
 
    pholes  = holes;
    Fault   = false;
 
    if( aHolesOnly )
        gluTessProperty( tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NEGATIVE );
    else
        gluTessProperty( tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
 
 
    if( contours.size() < 1 || vertices.size() < 3 )
    {
        error = "Tesselate(): not enough vertices";
        return false;
    }
 
    // finish the winding calculation on all vertices prior to setting 'fix'
    if( !fix )
    {
        for( unsigned int i = 0; i < contours.size(); ++i )
        {
            if( contours[i]->size() < 3 )
                continue;
 
            VERTEX_3D* vp0 = vertices[ contours[i]->back() ];
            VERTEX_3D* vp1 = vertices[ contours[i]->front() ];
            areas[i] += ( vp1->x - vp0->x ) * ( vp1->y + vp0->y );
        }
    }
 
    // prevent the addition of any further contours and contour vertices
    fix = true;
 
    // clear temporary internals which may have been used in a previous run
    clearTmp();
 
    // request an outline
    gluTessProperty( tess, GLU_TESS_BOUNDARY_ONLY, GL_TRUE );
 
    // adjust internal indices for extra points and holes
    if( holes )
        hidx = holes->GetSize();
    else
        hidx = 0;
 
    eidx = idx + hidx;
 
    if( aHolesOnly && ( checkNContours( true ) == 0 ) )
    {
        error = "tesselate(): no hole contours";
        return false;
    }
    else if( !aHolesOnly && ( checkNContours( false ) == 0 ) )
    {
        error = "tesselate(): no solid contours";
        return false;
    }
 
    // open the polygon
    gluTessBeginPolygon( tess, this );
 
    if( aHolesOnly )
    {
        pholes = NULL;  // do not accept foreign holes
        hidx = 0;
        eidx = idx;
 
        // add holes
        pushVertices( true );
 
        gluTessEndPolygon( tess );
 
        if( Fault )
            return false;
 
        return true;
    }
 
    // add solid outlines
    pushVertices( false );
 
    // close the polygon
    gluTessEndPolygon( tess );
 
    if( Fault )
        return false;
 
    // if there are no outlines we cannot proceed
    if( outline.empty() )
    {
        error = "tesselate(): no points in result";
        return false;
    }
 
    // at this point we have a solid outline; add it to the tesselator
    gluTessBeginPolygon( tess, this );
 
    if( !pushOutline( NULL ) )
        return false;
 
    // add the holes contained by this object
    pushVertices( true );
 
    // import external holes (if any)
    if( hidx && ( holes->Import( idx, tess ) < 0 ) )
    {
        std::ostringstream ostr;
        ostr << "Tesselate():FAILED: " << holes->GetError();
        error = ostr.str();
        return false;
    }
 
    if( Fault )
        return false;
 
    // erase the previous outline data and vertex order
    // but preserve the extra vertices
    while( !outline.empty() )
    {
        delete outline.back();
        outline.pop_back();
    }
 
    ordmap.clear();
    ord = 0;
 
    // go through the vertex lists and reset ephemeral parameters
    for( unsigned int i = 0; i < vertices.size(); ++i )
    {
        vertices[i]->o = -1;
    }
 
    for( unsigned int i = 0; i < extra_verts.size(); ++i )
    {
        extra_verts[i]->o = -1;
    }
 
    // close the polygon; this creates the outline points
    // and the point ordering list 'ordmap'
    solid.clear();
    gluTessEndPolygon( tess );
 
    // repeat the last operation but request a tesselated surface
    // rather than an outline; this creates the triangles list.
    gluTessProperty( tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE );
 
    gluTessBeginPolygon( tess, this );
 
    if( !pushOutline( holes ) )
        return false;
 
    gluTessEndPolygon( tess );
 
    if( Fault )
        return false;
 
    return true;
}
 
 
bool VRML_LAYER::pushOutline( VRML_LAYER* holes )
{
    // traverse the outline list to push all used vertices
    if( outline.size() < 1 )
    {
        error = "pushOutline() failed: no vertices to push";
        return false;
    }
 
    std::list<std::list<int>*>::const_iterator obeg = outline.begin();
    std::list<std::list<int>*>::const_iterator oend = outline.end();
 
    int nc = 0; // number of contours pushed
 
    int pi;
    std::list<int>::const_iterator  begin;
    std::list<int>::const_iterator  end;
    GLdouble pt[3];
    VERTEX_3D* vp;
 
    while( obeg != oend )
    {
        if( (*obeg)->size() < 3 )
        {
            ++obeg;
            continue;
        }
 
        gluTessBeginContour( tess );
 
        begin = (*obeg)->begin();
        end = (*obeg)->end();
 
        while( begin != end )
        {
            pi = *begin;
 
            if( pi < 0 || (unsigned int) pi > ordmap.size() )
            {
                gluTessEndContour( tess );
                error = "pushOutline():BUG: *outline.begin() is not a valid index to ordmap";
                return false;
            }
 
            // retrieve the actual index
            pi = ordmap[pi];
 
            vp = getVertexByIndex( pi, holes );
 
            if( !vp )
            {
                gluTessEndContour( tess );
                error = "pushOutline():: BUG: ordmap[n] is not a valid index to vertices[]";
                return false;
            }
 
            pt[0]   = vp->x;
            pt[1]   = vp->y;
            pt[2]   = 0.0;
            gluTessVertex( tess, pt, vp );
            ++begin;
        }
 
        gluTessEndContour( tess );
        ++obeg;
        ++nc;
    }
 
    if( !nc )
    {
        error = "pushOutline():: no valid contours available";
        return false;
    }
 
    return true;
}
 
 
bool VRML_LAYER::WriteVertices( double aZcoord, std::ostream& aOutFile, int aPrecision )
{
    if( ordmap.size() < 3 )
    {
        error = "WriteVertices(): not enough vertices";
        return false;
    }
 
    if( aPrecision < 4 )
        aPrecision = 4;
 
    int i, j;
 
    VERTEX_3D* vp = getVertexByIndex( ordmap[0], pholes );
 
    if( !vp )
        return false;
 
    std::string strx, stry, strz;
    FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
    FormatSinglet( aZcoord, aPrecision, strz );
 
    aOutFile << strx << " " << stry << " " << strz;
 
    for( i = 1, j = ordmap.size(); i < j; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
 
        if( !vp )
            return false;
 
        FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
 
        if( i & 1 )
            aOutFile << ", " << strx << " " << stry << " " << strz;
        else
            aOutFile << ",\n" << strx << " " << stry << " " << strz;
    }
 
    return !aOutFile.fail();
}
 
 
bool VRML_LAYER::Write3DVertices( double aTopZ, double aBottomZ, std::ostream& aOutFile,
                                  int aPrecision )
{
    if( ordmap.size() < 3 )
    {
        error = "Write3DVertices(): insufficient vertices";
        return false;
    }
 
    if( aPrecision < 4 )
        aPrecision = 4;
 
    if( aTopZ <= aBottomZ )
    {
        error = "Write3DVertices(): top <= bottom";
        return false;
    }
 
    int i, j;
 
    VERTEX_3D* vp = getVertexByIndex( ordmap[0], pholes );
 
    if( !vp )
        return false;
 
    std::string strx, stry, strz;
    FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
    FormatSinglet( aTopZ, aPrecision, strz );
 
    aOutFile << strx << " " << stry << " " << strz;
 
    for( i = 1, j = ordmap.size(); i < j; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
 
        if( !vp )
            return false;
 
        FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
 
        if( i & 1 )
            aOutFile << ", " << strx << " " << stry << " " << strz;
        else
            aOutFile << ",\n" << strx << " " << stry << " " << strz;
    }
 
    // repeat for the bottom layer
    vp = getVertexByIndex( ordmap[0], pholes );
    FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
    FormatSinglet( aBottomZ, aPrecision, strz );
 
    bool endl;
 
    if( i & 1 )
    {
        aOutFile << ", " << strx << " " << stry << " " << strz;
        endl = false;
    }
    else
    {
        aOutFile << ",\n" << strx << " " << stry << " " << strz;
        endl = true;
    }
 
    for( i = 1, j = ordmap.size(); i < j; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
        FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
 
        if( endl )
        {
            aOutFile << ", " << strx << " " << stry << " " << strz;
            endl = false;
        }
        else
        {
            aOutFile << ",\n" << strx << " " << stry << " " << strz;
            endl = true;
        }
    }
 
    return !aOutFile.fail();
}
 
 
bool VRML_LAYER::WriteIndices( bool aTopFlag, std::ostream& aOutFile )
{
    if( triplets.empty() )
    {
        error = "WriteIndices(): no triplets (triangular facets) to write";
        return false;
    }
 
    // go through the triplet list and write out the indices based on order
    std::list<TRIPLET_3D>::const_iterator   tbeg    = triplets.begin();
    std::list<TRIPLET_3D>::const_iterator   tend    = triplets.end();
 
    int i = 1;
 
    if( aTopFlag )
        aOutFile << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
    else
        aOutFile << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3  << ", -1";
 
    ++tbeg;
 
    while( tbeg != tend )
    {
        if( (i++ & 7) == 4 )
        {
            i = 1;
 
            if( aTopFlag )
                aOutFile << ",\n" << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
            else
                aOutFile << ",\n" << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3  << ", -1";
        }
        else
        {
            if( aTopFlag )
                aOutFile << ", " << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
            else
                aOutFile << ", " << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3  << ", -1";
        }
 
        ++tbeg;
    }
 
    return !aOutFile.fail();
}
 
 
bool VRML_LAYER::Write3DIndices( std::ostream& aOutFile, bool aIncludePlatedHoles )
{
    if( outline.empty() )
    {
        error = "WriteIndices(): no outline available";
        return false;
    }
 
    char mark;
    bool holes_only = triplets.empty();
 
    int i = 1;
    int idx2 = ordmap.size();    // index to the bottom vertices
 
    if( !holes_only )
    {
        mark = ',';
 
        // go through the triplet list and write out the indices based on order
        std::list<TRIPLET_3D>::const_iterator   tbeg    = triplets.begin();
        std::list<TRIPLET_3D>::const_iterator   tend    = triplets.end();
 
        // print out the top vertices
        aOutFile << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
        ++tbeg;
 
        while( tbeg != tend )
        {
            if( (i++ & 7) == 4 )
            {
                i = 1;
                aOutFile << ",\n" << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
            }
            else
            {
                aOutFile << ", " << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3  << ", -1";
            }
 
            ++tbeg;
        }
 
        // print out the bottom vertices
        tbeg = triplets.begin();
 
        while( tbeg != tend )
        {
            if( ( i++ & 7 ) == 4 )
            {
                i = 1;
                aOutFile << ",\n"
                         << ( tbeg->i2 + idx2 ) << ", " << ( tbeg->i1 + idx2 ) << ", "
                         << ( tbeg->i3 + idx2 ) << ", -1";
            }
            else
            {
                aOutFile << ", " << ( tbeg->i2 + idx2 ) << ", " << ( tbeg->i1 + idx2 ) << ", "
                         << ( tbeg->i3 + idx2 ) << ", -1";
            }
 
            ++tbeg;
        }
    }
    else
        mark = ' ';
 
    // print out indices for the walls joining top to bottom
    int lastPoint;
    int curPoint;
    int curContour = 0;
 
    std::list<std::list<int>*>::const_iterator  obeg    = outline.begin();
    std::list<std::list<int>*>::const_iterator  oend    = outline.end();
    std::list<int>* cp;
    std::list<int>::const_iterator  cbeg;
    std::list<int>::const_iterator  cend;
 
    i = 2;
 
    while( obeg != oend )
    {
        cp = *obeg;
 
        if( cp->size() < 3 )
        {
            ++obeg;
            ++curContour;
            continue;
        }
 
        cbeg      = cp->begin();
        cend      = cp->end();
        lastPoint = *(cbeg++);
 
        // skip all PTH vertices which are not in a solid outline
        if( !aIncludePlatedHoles && !solid[curContour]
            && getVertexByIndex( ordmap[lastPoint], pholes )->pth )
        {
            ++obeg;
            ++curContour;
            continue;
        }
 
        while( cbeg != cend )
        {
            curPoint = *(cbeg++);
 
            if( !holes_only )
            {
                if( ( i++ & 3 ) == 2 )
                {
                    i = 1;
                    aOutFile << mark << "\n"
                             << curPoint << ", " << lastPoint << ", " << curPoint + idx2;
                    aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
                             << lastPoint + idx2 << ", -1";
                }
                else
                {
                    aOutFile << mark << " " << curPoint << ", " << lastPoint << ", "
                             << curPoint + idx2;
                    aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
                             << lastPoint + idx2 << ", -1";
                }
            }
            else
            {
                if( (i++ & 3) == 2 )
                {
                    i = 1;
                    aOutFile << mark << "\n"
                             << curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
                    aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
                             << lastPoint << ", -1";
                }
                else
                {
                    aOutFile << mark << " " << curPoint << ", " << curPoint + idx2 << ", "
                             << lastPoint;
                    aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
                             << lastPoint << ", -1";
                }
            }
 
            mark = ',';
            lastPoint = curPoint;
        }
 
        // check if the loop needs to be closed
        cbeg = cp->begin();
        cend = --cp->end();
 
        curPoint = *(cbeg);
        lastPoint  = *(cend);
 
        if( !holes_only )
        {
            if( ( i++ & 3 ) == 2 )
            {
                aOutFile << ",\n" << curPoint << ", " << lastPoint << ", " << curPoint + idx2;
                aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
                         << lastPoint + idx2 << ", -1";
            }
            else
            {
                aOutFile << ", " << curPoint << ", " << lastPoint << ", " << curPoint + idx2;
                aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
                         << lastPoint + idx2 << ", -1";
            }
        }
        else
        {
            if( ( i++ & 3 ) == 2 )
            {
                aOutFile << ",\n" << curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
                aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
                         << lastPoint << ", -1";
            }
            else
            {
                aOutFile << ", " << curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
                aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
                         << lastPoint << ", -1";
            }
        }
 
        ++obeg;
        ++curContour;
    }
 
    return !aOutFile.fail();
}
 
 
bool VRML_LAYER::addTriplet( VERTEX_3D* p0, VERTEX_3D* p1, VERTEX_3D* p2 )
{
    double  dx0 = p1->x - p0->x;
    double  dx1 = p2->x - p0->x;
    double  dx2 = p2->x - p1->x;
 
    double  dy0 = p1->y - p0->y;
    double  dy1 = p2->y - p0->y;
    double  dy2 = p2->y - p1->y;
 
    dx0 *= dx0;
    dx1 *= dx1;
    dx2 *= dx2;
 
    dy0 *= dy0;
    dy1 *= dy1;
    dy2 *= dy2;
 
    // this number is chosen because we shall only write 9 decimal places
    // at most on the VRML output
    double err = 0.000000001;
 
    // test if the triangles are degenerate (equal points)
    if( ( dx0 + dy0 ) < err )
        return false;
 
    if( ( dx1 + dy1 ) < err )
        return false;
 
    if( ( dx2 + dy2 ) < err )
        return false;
 
    triplets.emplace_back( p0->o, p1->o, p2->o );
 
    return true;
}
 
 
VERTEX_3D* VRML_LAYER::AddExtraVertex( double aXpos, double aYpos, bool aPlatedHole )
{
    VERTEX_3D* vertex = new VERTEX_3D;
 
    if( eidx == 0 )
        eidx = idx + hidx;
 
    vertex->x   = aXpos;
    vertex->y   = aYpos;
    vertex->i   = eidx++;
    vertex->o   = -1;
    vertex->pth = aPlatedHole;
 
    extra_verts.push_back( vertex );
 
    return vertex;
}
 
 
void VRML_LAYER::glStart( GLenum cmd )
{
    glcmd = cmd;
 
    while( !vlist.empty() )
        vlist.pop_back();
}
 
 
void VRML_LAYER::glPushVertex( VERTEX_3D* vertex )
{
    if( vertex->o < 0 )
    {
        vertex->o = ord++;
        ordmap.push_back( vertex->i );
    }
 
    vlist.push_back( vertex );
}
 
 
void VRML_LAYER::glEnd( void )
{
    switch( glcmd )
    {
    case GL_LINE_LOOP:
    {
        // add the loop to the list of outlines
        std::list<int>* loop = new std::list<int>;
 
        double firstX = 0.0;
        double firstY = 0.0;
        double lastX = 0.0;
        double lastY = 0.0;
        double curX, curY;
        double area = 0.0;
 
        if( vlist.size() > 0 )
        {
            loop->push_back( vlist[0]->o );
            firstX = vlist[0]->x;
            firstY = vlist[0]->y;
            lastX = firstX;
            lastY = firstY;
        }
 
        for( size_t i = 1; i < vlist.size(); ++i )
        {
            loop->push_back( vlist[i]->o );
            curX = vlist[i]->x;
            curY = vlist[i]->y;
            area += ( curX - lastX ) * ( curY + lastY );
            lastX = curX;
            lastY = curY;
        }
 
        area += ( firstX - lastX ) * ( firstY + lastY );
 
        outline.push_back( loop );
 
        if( area <= 0.0 )
            solid.push_back( true );
        else
            solid.push_back( false );
        }
 
        break;
 
    case GL_TRIANGLE_FAN:
        processFan();
        break;
 
    case GL_TRIANGLE_STRIP:
        processStrip();
        break;
 
    case GL_TRIANGLES:
        processTri();
        break;
 
    default:
        break;
    }
 
    while( !vlist.empty() )
        vlist.pop_back();
 
    glcmd = 0;
}
 
 
void VRML_LAYER::SetGLError( GLenum errorID )
{
    const char * msg = (const char*)gluErrorString( errorID );
 
    // If errorID is an illegal id, gluErrorString returns NULL
    if( msg )
        error = msg;
    else
        error.clear();
 
    if( error.empty() )
    {
        std::ostringstream ostr;
        ostr << "Unknown OpenGL error: " << errorID;
        error = ostr.str();
    }
}
 
 
void VRML_LAYER::processFan( void )
{
    if( vlist.size() < 3 )
        return;
 
    VERTEX_3D* p0 = vlist[0];
 
    int i;
    int end = vlist.size();
 
    for( i = 2; i < end; ++i )
    {
        addTriplet( p0, vlist[i - 1], vlist[i] );
    }
}
 
 
void VRML_LAYER::processStrip( void )
{
    // note: (source: http://www.opengl.org/wiki/Primitive)
    // GL_TRIANGLE_STRIP​: Every group of 3 adjacent vertices forms a triangle.
    // The face direction of the strip is determined by the winding of the
    // first triangle. Each successive triangle will have its effective face
    // order reverse, so the system compensates for that by testing it in the
    // opposite way. A vertex stream of n length will generate n-2 triangles.
 
    if( vlist.size() < 3 )
        return;
 
    int i;
    int end = vlist.size();
    bool flip = false;
 
    for( i = 2; i < end; ++i )
    {
        if( flip )
        {
            addTriplet( vlist[i - 1], vlist[i - 2], vlist[i] );
            flip = false;
        }
        else
        {
            addTriplet( vlist[i - 2], vlist[i - 1], vlist[i] );
            flip = true;
        }
    }
}
 
 
void VRML_LAYER::processTri( void )
{
    // notes:
    // 1. each successive group of 3 vertices is a triangle
    // 2. as per OpenGL specification, any incomplete triangles are to be ignored
 
    if( vlist.size() < 3 )
        return;
 
    int i;
    int end = vlist.size();
 
    for( i = 2; i < end; i += 3 )
        addTriplet( vlist[i - 2], vlist[i - 1], vlist[i] );
}
 
 
int VRML_LAYER::checkNContours( bool holes )
{
    int nc = 0;     // number of contours
 
    if( contours.empty() )
        return 0;
 
    for( size_t i = 0; i < contours.size(); ++i )
    {
        if( contours[i]->size() < 3 )
            continue;
 
        if( ( holes && areas[i] <= 0.0 ) || ( !holes && areas[i] > 0.0 ) )
            continue;
 
        ++nc;
    }
 
    return nc;
}
 
 
void VRML_LAYER::pushVertices( bool holes )
{
    // push the internally held vertices
    unsigned int i;
 
    std::list<int>::const_iterator  begin;
    std::list<int>::const_iterator  end;
    GLdouble pt[3];
    VERTEX_3D* vp;
 
    for( i = 0; i < contours.size(); ++i )
    {
        if( contours[i]->size() < 3 )
            continue;
 
        if( ( holes && areas[i] <= 0.0 ) || ( !holes && areas[i] > 0.0 ) )
            continue;
 
        gluTessBeginContour( tess );
 
        begin = contours[i]->begin();
        end = contours[i]->end();
 
        while( begin != end )
        {
            vp = vertices[ *begin ];
            pt[0]   = vp->x;
            pt[1]   = vp->y;
            pt[2]   = 0.0;
            gluTessVertex( tess, pt, vp );
            ++begin;
        }
 
        gluTessEndContour( tess );
    }
 
    return;
}
 
 
VERTEX_3D* VRML_LAYER::getVertexByIndex( int aPointIndex, VRML_LAYER* holes )
{
    if( aPointIndex < 0 || (unsigned int) aPointIndex >= ( idx + hidx + extra_verts.size() ) )
    {
        error = "getVertexByIndex():BUG: invalid index";
        return NULL;
    }
 
    if( aPointIndex < idx )
    {
        // vertex is in the vertices[] list
        return vertices[ aPointIndex ];
    }
    else if( aPointIndex >= idx + hidx )
    {
        // vertex is in the extra_verts[] list
        return extra_verts[aPointIndex - idx - hidx];
    }
 
    // vertex is in the holes object
    if( !holes )
    {
        error = "getVertexByIndex():BUG: invalid index";
        return NULL;
    }
 
    VERTEX_3D* vp = holes->GetVertexByIndex( aPointIndex );
 
    if( !vp )
    {
        std::ostringstream ostr;
        ostr << "getVertexByIndex():FAILED: " << holes->GetError();
        error = ostr.str();
        return NULL;
    }
 
    return vp;
}
 
 
int VRML_LAYER::GetSize( void )
{
    return vertices.size();
}
 
 
int VRML_LAYER::Import( int start, GLUtesselator* aTesselator )
{
    if( start < 0 )
    {
        error = "Import(): invalid index ( start < 0 )";
        return -1;
    }
 
    if( !aTesselator )
    {
        error = "Import(): NULL tesselator pointer";
        return -1;
    }
 
    unsigned int i, j;
 
    // renumber from 'start'
    for( i = 0, j = vertices.size(); i < j; ++i )
    {
        vertices[i]->i = start++;
        vertices[i]->o = -1;
    }
 
    // push each contour to the tesselator
    VERTEX_3D* vp;
    GLdouble pt[3];
 
    std::list<int>::const_iterator cbeg;
    std::list<int>::const_iterator cend;
 
    for( i = 0; i < contours.size(); ++i )
    {
        if( contours[i]->size() < 3 )
            continue;
 
        cbeg = contours[i]->begin();
        cend = contours[i]->end();
 
        gluTessBeginContour( aTesselator );
 
        while( cbeg != cend )
        {
            vp = vertices[ *cbeg++ ];
            pt[0] = vp->x;
            pt[1] = vp->y;
            pt[2] = 0.0;
            gluTessVertex( aTesselator, pt, vp );
        }
 
        gluTessEndContour( aTesselator );
    }
 
    return start;
}
 
 
VERTEX_3D* VRML_LAYER::GetVertexByIndex( int aPointIndex )
{
    int i0 = vertices[0]->i;
 
    if( aPointIndex < i0 || aPointIndex >= ( i0 + (int) vertices.size() ) )
    {
        error = "GetVertexByIndex(): invalid index";
        return NULL;
    }
 
    return vertices[aPointIndex - i0];
}
 
 
const std::string& VRML_LAYER::GetError( void )
{
    return error;
}
 
 
void VRML_LAYER::SetVertexOffsets( double aXoffset, double aYoffset )
{
    offsetX = aXoffset;
    offsetY = aYoffset;
    return;
}
 
 
bool VRML_LAYER::Get3DTriangles( std::vector< double >& aVertexList,
                                 std::vector< int > &aIndexPlane, std::vector< int > &aIndexSide,
                                 double aTopZ, double aBotZ )
{
    aVertexList.clear();
    aIndexPlane.clear();
    aIndexSide.clear();
 
    if( ordmap.size() < 3 || outline.empty() )
        return false;
 
    if( aTopZ <= aBotZ )
    {
        double tmp = aBotZ;
        aBotZ = aTopZ;
        aTopZ = tmp;
    }
 
    VERTEX_3D* vp = getVertexByIndex( ordmap[0], pholes );
 
    if( !vp )
        return false;
 
    size_t i;
    size_t vsize = ordmap.size();
 
    // top vertices
    for( i = 0; i < vsize; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
 
        if( !vp )
        {
            aVertexList.clear();
            return false;
        }
 
        aVertexList.push_back( vp->x + offsetX );
        aVertexList.push_back( vp->y + offsetY );
        aVertexList.push_back( aTopZ );
    }
 
    // bottom vertices
    for( i = 0; i < vsize; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
 
        aVertexList.push_back( vp->x + offsetX );
        aVertexList.push_back( vp->y + offsetY );
        aVertexList.push_back( aBotZ );
    }
 
    // create the index lists .. it is difficult to estimate the list size
    // a priori so instead we use a vector to help
 
    bool holes_only = triplets.empty();
 
    if( !holes_only )
    {
        // go through the triplet list and write out the indices based on order
        std::list< TRIPLET_3D >::const_iterator tbeg = triplets.begin();
        std::list< TRIPLET_3D >::const_iterator tend = triplets.end();
 
        std::vector< int > aIndexBot;
 
        while( tbeg != tend )
        {
            // top vertices
            aIndexPlane.push_back( (int) tbeg->i1 );
            aIndexPlane.push_back( (int) tbeg->i2 );
            aIndexPlane.push_back( (int) tbeg->i3 );
 
            // bottom vertices
            aIndexBot.push_back( (int) ( tbeg->i2 + vsize ) );
            aIndexBot.push_back( (int) ( tbeg->i1 + vsize ) );
            aIndexBot.push_back( (int) ( tbeg->i3 + vsize ) );
 
            ++tbeg;
        }
 
        aIndexPlane.insert( aIndexPlane.end(), aIndexBot.begin(), aIndexBot.end() );
    }
 
    // compile indices for the walls joining top to bottom
    int lastPoint;
    int curPoint;
 
    std::list< std::list< int >* >::const_iterator  obeg = outline.begin();
    std::list< std::list< int >* >::const_iterator  oend = outline.end();
    std::list< int >* cp;
    std::list< int >::const_iterator  cbeg;
    std::list< int >::const_iterator  cend;
 
    i = 2;
 
    while( obeg != oend )
    {
        cp = *obeg;
 
        if( cp->size() < 3 )
        {
            ++obeg;
            continue;
        }
 
        cbeg      = cp->begin();
        cend      = cp->end();
        lastPoint = *(cbeg++);
 
        while( cbeg != cend )
        {
            curPoint = *(cbeg++);
 
            if( !holes_only )
            {
                aIndexSide.push_back( curPoint );
                aIndexSide.push_back( lastPoint );
                aIndexSide.push_back( (int)( curPoint + vsize ) );
 
                aIndexSide.push_back( (int)( curPoint + vsize ) );
                aIndexSide.push_back( lastPoint );
                aIndexSide.push_back( (int)( lastPoint + vsize ) );
            }
            else
            {
                aIndexSide.push_back( curPoint );
                aIndexSide.push_back( (int)( curPoint + vsize ) );
                aIndexSide.push_back( lastPoint );
 
                aIndexSide.push_back( (int)( curPoint + vsize ) );
                aIndexSide.push_back( (int)( lastPoint + vsize ) );
                aIndexSide.push_back( lastPoint );
            }
 
            lastPoint = curPoint;
        }
 
        // check if the loop needs to be closed
        cbeg = cp->begin();
        cend = --cp->end();
 
        curPoint = *(cbeg);
        lastPoint  = *(cend);
 
        if( !holes_only )
        {
            aIndexSide.push_back( curPoint );
            aIndexSide.push_back( lastPoint );
            aIndexSide.push_back( (int)( curPoint + vsize ) );
 
            aIndexSide.push_back( (int)( curPoint + vsize ) );
            aIndexSide.push_back( lastPoint );
            aIndexSide.push_back( (int)( lastPoint + vsize ) );
        }
        else
        {
            aIndexSide.push_back( curPoint );
            aIndexSide.push_back( (int)( curPoint + vsize ) );
            aIndexSide.push_back( lastPoint );
 
            aIndexSide.push_back( (int)( curPoint + vsize ) );
            aIndexSide.push_back( (int)( lastPoint + vsize ) );
            aIndexSide.push_back( lastPoint );
        }
 
        ++obeg;
    }
 
    return true;
}
 
 
bool VRML_LAYER::Get2DTriangles( std::vector< double >& aVertexList,
                                 std::vector< int > &aIndexPlane, double aHeight, bool aTopPlane )
{
    aVertexList.clear();
    aIndexPlane.clear();
 
    if( ordmap.size() < 3 || outline.empty() )
        return false;
 
    VERTEX_3D* vp = getVertexByIndex( ordmap[0], pholes );
 
    if( !vp )
        return false;
 
    size_t i;
    size_t vsize = ordmap.size();
 
    // vertices
    for( i = 0; i < vsize; ++i )
    {
        vp = getVertexByIndex( ordmap[i], pholes );
 
        if( !vp )
        {
            aVertexList.clear();
            return false;
        }
 
        aVertexList.push_back( vp->x + offsetX );
        aVertexList.push_back( vp->y + offsetY );
        aVertexList.push_back( aHeight );
    }
 
    // create the index lists .. it is difficult to estimate the list size
    // a priori so instead we use a vector to help
 
    if( triplets.empty() )
        return false;
 
    // go through the triplet list and write out the indices based on order
    std::list< TRIPLET_3D >::const_iterator tbeg = triplets.begin();
    std::list< TRIPLET_3D >::const_iterator tend = triplets.end();
 
    if( aTopPlane )
    {
        while( tbeg != tend )
        {
            // top vertices
            aIndexPlane.push_back( (int) tbeg->i1 );
            aIndexPlane.push_back( (int) tbeg->i2 );
            aIndexPlane.push_back( (int) tbeg->i3 );
 
            ++tbeg;
        }
    }
    else
    {
        while( tbeg != tend )
        {
            // bottom vertices
            aIndexPlane.push_back( (int) ( tbeg->i2 ) );
            aIndexPlane.push_back( (int) ( tbeg->i1 ) );
            aIndexPlane.push_back( (int) ( tbeg->i3 ) );
 
            ++tbeg;
        }
    }
 
    return true;
}