kicad/utils/idftools/vrml_layer.cpp

2036 lines
49 KiB
C++
Raw Normal View History

/*
* file: vrml_layer.cpp
*
* This program source code file is part of KiCad, a free EDA CAD application.
2021-07-27 21:24:40 +00:00
* Copyright (C) 2021 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, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
// 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 <sstream>
#include <string>
#include <iomanip>
#include <cmath>
#include <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
2021-07-27 21:24:40 +00:00
csides = ( ( (double) csides ) * minSegLength / maxSegLength );
}
if( csides < 3 )
csides = 3;
2021-07-27 21:24:40 +00:00
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],
2021-07-27 21:24:40 +00:00
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;
}
2021-07-27 21:24:40 +00:00
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();
2014-06-08 10:35:42 +00:00
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;
2014-06-08 10:35:42 +00:00
triplets.clear();
solid.clear();
for( i = outline.size(); i > 0; --i )
{
delete outline.back();
outline.pop_back();
}
2014-06-08 10:35:42 +00:00
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
2014-06-08 10:35:42 +00:00
vlist.clear();
// go through the vertex list and reset ephemeral parameters
for( i = 0; i < vertices.size(); ++i )
{
vertices[i]->o = -1;
}
}
2021-07-27 21:24:40 +00:00
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;
}
2021-07-27 21:24:40 +00:00
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 )
2022-01-18 02:18:55 +00:00
{
fail |= !AddVertex( aContourID, aXpos + aRadius * cos( angle ),
2022-01-18 02:18:55 +00:00
aYpos - aRadius * sin( angle ) );
}
}
else
{
fail |= !AddVertex( aContourID, aXpos + aRadius, aYpos );
for( double angle = da; angle < M_PI * 2; angle += da )
2022-01-18 02:18:55 +00:00
{
fail |= !AddVertex( aContourID, aXpos + aRadius * cos( angle ),
2022-01-18 02:18:55 +00:00
aYpos + aRadius * sin( angle ) );
}
}
return !fail;
}
2021-07-27 21:24:40 +00:00
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 );
}
2021-07-27 21:24:40 +00:00
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,
2021-07-27 21:24:40 +00:00
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
2022-01-18 02:18:55 +00:00
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;
2022-01-18 02:18:55 +00:00
for( double ang = aStartAngle; ang < aAngle; ang += da )
2022-01-18 02:18:55 +00:00
{
fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),
2022-01-18 02:18:55 +00:00
aCenterY + aRadius * sin( ang ) );
}
}
else
{
aAngle += aStartAngle;
2022-01-18 02:18:55 +00:00
for( double ang = aStartAngle; ang > aAngle; ang += da )
2022-01-18 02:18:55 +00:00
{
fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),
2022-01-18 02:18:55 +00:00
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;
}
2014-06-08 10:35:42 +00:00
// 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;
}
2014-06-08 10:35:42 +00:00
// 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
2014-06-08 10:35:42 +00:00
while( !outline.empty() )
{
delete outline.back();
outline.pop_back();
}
2014-06-08 10:35:42 +00:00
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;
}
2014-06-08 10:35:42 +00:00
// close the polygon; this creates the outline points
// and the point ordering list 'ordmap'
solid.clear();
gluTessEndPolygon( tess );
2014-06-08 10:35:42 +00:00
// 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 );
2014-06-08 10:35:42 +00:00
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() )
{
2014-06-08 10:35:42 +00:00
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 )
{
2014-06-08 10:35:42 +00:00
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();
}
2021-07-27 21:24:40 +00:00
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 )
{
2021-07-27 21:24:40 +00:00
if( ( i++ & 7 ) == 4 )
{
i = 1;
2021-07-27 21:24:40 +00:00
aOutFile << ",\n"
<< ( tbeg->i2 + idx2 ) << ", " << ( tbeg->i1 + idx2 ) << ", "
<< ( tbeg->i3 + idx2 ) << ", -1";
}
else
{
2021-07-27 21:24:40 +00:00
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;
2021-07-27 21:24:40 +00:00
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 )
{
2021-07-27 21:24:40 +00:00
if( ( i++ & 3 ) == 2 )
{
i = 1;
2021-07-27 21:24:40 +00:00
aOutFile << mark << "\n"
<< curPoint << ", " << lastPoint << ", " << curPoint + idx2;
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
<< lastPoint + idx2 << ", -1";
}
else
{
2021-07-27 21:24:40 +00:00
aOutFile << mark << " " << curPoint << ", " << lastPoint << ", "
<< curPoint + idx2;
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
<< lastPoint + idx2 << ", -1";
}
}
else
{
if( (i++ & 3) == 2 )
{
i = 1;
2021-07-27 21:24:40 +00:00
aOutFile << mark << "\n"
<< curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
<< lastPoint << ", -1";
}
else
{
2021-07-27 21:24:40 +00:00
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 )
{
2021-07-27 21:24:40 +00:00
if( ( i++ & 3 ) == 2 )
{
aOutFile << ",\n" << curPoint << ", " << lastPoint << ", " << curPoint + idx2;
2021-07-27 21:24:40 +00:00
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
<< lastPoint + idx2 << ", -1";
}
else
{
aOutFile << ", " << curPoint << ", " << lastPoint << ", " << curPoint + idx2;
2021-07-27 21:24:40 +00:00
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint << ", "
<< lastPoint + idx2 << ", -1";
}
}
else
{
2021-07-27 21:24:40 +00:00
if( ( i++ & 3 ) == 2 )
{
aOutFile << ",\n" << curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
2021-07-27 21:24:40 +00:00
aOutFile << ", -1, " << curPoint + idx2 << ", " << lastPoint + idx2 << ", "
<< lastPoint << ", -1";
}
else
{
aOutFile << ", " << curPoint << ", " << curPoint + idx2 << ", " << lastPoint;
2021-07-27 21:24:40 +00:00
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;
2014-06-08 10:35:42 +00:00
// 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:
2021-07-27 21:24:40 +00:00
{
// add the loop to the list of outlines
std::list<int>* loop = new std::list<int>;
2021-07-27 21:24:40 +00:00
double firstX = 0.0;
double firstY = 0.0;
double lastX = 0.0;
double lastY = 0.0;
double curX, curY;
double area = 0.0;
2021-07-27 21:24:40 +00:00
if( vlist.size() > 0 )
{
loop->push_back( vlist[0]->o );
firstX = vlist[0]->x;
firstY = vlist[0]->y;
lastX = firstX;
lastY = firstY;
}
2021-07-27 21:24:40 +00:00
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;
}
2021-07-27 21:24:40 +00:00
area += ( firstX - lastX ) * ( firstY + lastY );
2021-07-27 21:24:40 +00:00
outline.push_back( loop );
2021-07-27 21:24:40 +00:00
if( area <= 0.0 )
solid.push_back( true );
else
solid.push_back( false );
}
2021-07-27 21:24:40 +00:00
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,
2021-07-27 21:24:40 +00:00
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;
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;
2021-07-27 21:24:40 +00:00
while( obeg != oend )
{
cp = *obeg;
if( cp->size() < 3 )
{
++obeg;
++curContour;
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;
++curContour;
}
return true;
}
bool VRML_LAYER::Get2DTriangles( std::vector< double >& aVertexList,
2021-07-27 21:24:40 +00:00
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;
}