Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtGeomKernel :

Browse Source 
- correzione alla triangolazione delle bezier.
This commit is contained in:
Daniele Bariletti
2024-07-10 16:41:34 +02:00
parent 79b470b18b
commit f7a28447fb
2 changed files with 133 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tree.cpp
+132 -127
View File
@@ -1610,11 +1610,7 @@ Tree::GetPolygons( POLYLINEMATRIX& vvPolygons, bool bForTriangulation, POLYLINEM
// trimmata
else {
POLYLINEVECTOR vPolygonsBasic ;
POLYLINEVECTOR vPolygonsBasic3d ;
if ( bForTriangulation)
GetPolygonsBasic( vPolygonsBasic, vPolygonsBasic3d) ;
else
GetPolygonsBasic( vPolygonsBasic) ;
GetPolygonsBasic( vPolygonsBasic) ;
// aggiungo 4 elementi al vettore che contiene ciò che resta degli edge dopo il trim
m_vCEdge2D.clear() ;
for ( int i = 0 ; i < 4 ; ++i) {
@@ -1624,6 +1620,11 @@ Tree::GetPolygons( POLYLINEMATRIX& vvPolygons, bool bForTriangulation, POLYLINEM
// percorro i loop, trovo le intersezioni con le celle e le categorizzo
if ( ! TraceLoopLabelCell( vPolygonsBasic))
return false ;
POLYLINEVECTOR vPolygonsBasic3d ;
if ( bForTriangulation) {
vPolygonsBasic.clear() ;
GetPolygonsBasic( vPolygonsBasic, vPolygonsBasic3d) ;
}
// scorro sulle celle e costruisco i poligoni
int nCells = int( vPolygonsBasic.size()) ;
for ( int i = 0 ; i < nCells ; ++ i) {
@@ -1660,12 +1661,15 @@ Tree::GetPolygons( POLYLINEMATRIX& vvPolygons, bool bForTriangulation, POLYLINEM
// in questo for analizzo solo i loop che tagliano la cella
while( (int)vToCheck.size() != 0) {
int nPolyBefore = nPoly ;
CreateCellPolygons( i, vvPolygons, vvPolygons3d, vToCheck, nPoly, vnParentChunk, vPolygonsBasic[i], vPolygonsBasic3d[i]) ;
PolyLine pl3d ;
if( bForTriangulation)
pl3d = vPolygonsBasic3d[i] ;
CreateCellPolygons( i, vvPolygons, vvPolygons3d, vToCheck, nPoly, vnParentChunk, vPolygonsBasic[i], pl3d) ;
if ( nPolyBefore == nPoly)
break ;
}
// ora analizzo anche i loop che sono contenuti nella cella
CreateIslandAndHoles( i, vvPolygons, vvPolygons3d, nPoly, vnParentChunk) ;
CreateIslandAndHoles( i, vvPolygons, vvPolygons3d, nPoly, vnParentChunk, bForTriangulation) ;
}
}
return true ;
@@ -1747,7 +1751,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons, bool bForTriangulation, POLYL
for ( int j : vNeigh) {
Point3d pt( m_mTree.at( j).GetTopRight().x, m_mTree.at( nId).GetBottomLeft().y) ;
vVertices.push_back( pt) ;
vVertices3d.push_back( m_mVert[j][1]) ;
vVertices3d.push_back( m_mVert[j][2]) ;
}
}
else {
@@ -1772,7 +1776,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons, bool bForTriangulation, POLYL
for ( int j : vNeigh) {
Point3d pt( m_mTree.at( nId).GetTopRight().x, m_mTree.at(j).GetBottomLeft().y) ;
vVertices.push_back( pt) ;
vVertices3d.push_back( m_mVert[j][1]) ;
vVertices3d.push_back( m_mVert[j][0]) ;
}
}
else {
@@ -1805,7 +1809,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons, bool bForTriangulation, POLYL
for ( int j : vNeigh) {
Point3d pt( m_mTree.at( j).GetBottomLeft().x, m_mTree.at( nId).GetTopRight().y) ;
vVertices.push_back( pt) ;
vVertices3d.push_back( m_mVert[j][3]) ;
vVertices3d.push_back( m_mVert[j][0]) ;
}
}
else {
@@ -1831,7 +1835,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons, bool bForTriangulation, POLYL
for ( int j : vNeigh) {
Point3d pt( m_mTree.at( nId).GetBottomLeft().x, m_mTree.at(j).GetTopRight().y) ;
vVertices.push_back( pt) ;
vVertices3d.push_back( m_mVert[j][3]) ;
vVertices3d.push_back( m_mVert[j][2]) ;
}
}
else {
@@ -2951,14 +2955,19 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
vEdgeVertex[1].push_back( m_mTree[nId].GetTopLeft()) ;
vEdgeVertex[2].push_back( m_mTree[nId].GetBottomLeft()) ;
vEdgeVertex[3].push_back( m_mTree[nId].GetBottomRight()) ;
vEdgeVertex3d[0].push_back( m_mVert[nId][2]) ;
vEdgeVertex3d[1].push_back( m_mVert[nId][3]) ;
vEdgeVertex3d[2].push_back( m_mVert[nId][0]) ;
vEdgeVertex3d[3].push_back( m_mVert[nId][1]) ;
// capisco se sono in modalità ForTriangulation
bool bForTriangulation = plCell3d.GetPointNbr() != 0 ;
if ( bForTriangulation) {
vEdgeVertex3d[0].push_back( m_mVert[nId][2]) ;
vEdgeVertex3d[1].push_back( m_mVert[nId][3]) ;
vEdgeVertex3d[2].push_back( m_mVert[nId][0]) ;
vEdgeVertex3d[3].push_back( m_mVert[nId][1]) ;
}
// la PolyLine è riempita a partire dal lato bottom
Point3d ptStart, pt3d ;
plCell.GetFirstPoint( ptStart) ;
plCell3d.GetFirstPoint( pt3d) ;
if ( bForTriangulation)
plCell3d.GetFirstPoint( pt3d) ;
INTVECTOR vEdge = { 2, 3, 0, 1} ;
for ( int p = 0 ; p < 4 ; ++ p) {
int j = vEdge[p] ;
@@ -2966,9 +2975,12 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
if ( j == 3)
next = 0 ;
Point3d ptToAdd ;
while ( plCell.GetNextPoint( ptToAdd) && plCell3d.GetNextPoint( pt3d) && ! AreSamePointExact( ptToAdd, vEdgeVertex[next][0])) {
while ( plCell.GetNextPoint( ptToAdd) && ! AreSamePointExact( ptToAdd, vEdgeVertex[next][0])) {
vEdgeVertex[j].push_back( ptToAdd) ;
vEdgeVertex3d[j].push_back( pt3d) ;
if ( bForTriangulation) {
plCell3d.GetNextPoint( pt3d) ;
vEdgeVertex3d[j].push_back( pt3d) ;
}
}
}
@@ -3015,46 +3027,8 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
Vector3d vLast = ptLast - ptSecondToLast ;
vLast.Normalize() ;
Vector3d vEdge ;
//if ( AreSameEdge( nEdge, 0)) {
// if ( AreSamePointExact( ptLast, ptTl)) {
// vEdge = m_mTree[nId].GetBottomLeft() - ptTl ;
// vEdge.Normalize() ;
// if ( AreOppositeVectorApprox( vLast, vEdge)) {
// plTrimmedPoly.EraseLastUPoint() ;
// nEdge = 1 ;
// }
// }
//}
//else if ( AreSameEdge( nEdge, 1) && AreSamePointExact( ptLast, m_mTree[nId].GetBottomLeft())) {
// vEdge = ptBr - m_mTree[nId].GetBottomLeft() ;
// vEdge.Normalize() ;
// if ( AreOppositeVectorApprox( vLast, vEdge)) {
// plTrimmedPoly.EraseLastUPoint() ;
// nEdge = 2 ;
// }
//}
//else if ( AreSameEdge( nEdge, 2)) {
// if ( AreSamePointExact( ptLast, ptBr)) {
// vEdge = m_mTree[nId].GetTopRight() - ptBr ;
// vEdge.Normalize() ;
// if ( AreOppositeVectorApprox( vLast, vEdge)) {
// plTrimmedPoly.EraseLastUPoint() ;
// nEdge = 3 ;
// }
// }
//}
//else if ( AreSameEdge( nEdge, 3) && AreSamePointExact( ptLast, m_mTree[nId].GetTopRight())) {
// vEdge = ptTl - m_mTree[nId].GetTopRight() ;
// vEdge.Normalize() ;
// if ( AreOppositeVectorApprox( vLast, vEdge)) {
// plTrimmedPoly.EraseLastUPoint() ;
// nEdge = 0 ;
// }
//}
// estendo: se l'ultimo tratto è sovrapposto e controverso allora elimino l'ultimo punto
if ( nEdge == 0 || nEdge == 7 ) {
//vEdge = ptTl - m_mTree[nId].GetTopRight() ;
vEdge.Set( 1,0,0) ;
if ( AreOppositeVectorApprox( vLast, vEdge)) {
plTrimmedPoly.EraseLastUPoint() ;
@@ -3063,7 +3037,6 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
}
}
else if ( nEdge == 1 || nEdge == 4 ) {
//vEdge = ptBr - m_mTree[nId].GetBottomLeft() ;
vEdge.Set( 0,-1,0) ;
if ( AreOppositeVectorApprox( vLast, vEdge)) {
plTrimmedPoly.EraseLastUPoint() ;
@@ -3072,7 +3045,6 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
}
}
else if ( nEdge == 2 || nEdge == 5 ) {
//vEdge = ptTl - m_mTree[nId].GetTopRight() ;
vEdge.Set( -1,0,0) ;
if ( AreOppositeVectorApprox( vLast, vEdge)) {
plTrimmedPoly.EraseLastUPoint() ;
@@ -3081,7 +3053,6 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
}
}
else if ( nEdge == 3 || nEdge == 6 ) {
//vEdge = m_mTree[nId].GetTopRight() - ptBr ;
vEdge.Set( 0,1,0) ;
if ( AreOppositeVectorApprox( vLast, vEdge)) {
plTrimmedPoly.EraseLastUPoint() ;
@@ -3218,12 +3189,14 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
if ( dArea > 0) {
vCellPolygons.push_back( plTrimmedPoly) ;
vPolygons.push_back( vCellPolygons) ;
vCellPolygons3d.push_back( plTrimmedPoly3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
vCellPolygons.clear() ;
if( bForTriangulation) {
vCellPolygons3d.push_back( plTrimmedPoly3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
vCellPolygons3d.clear() ;
}
++ nPoly ;
vnParentChunk.push_back( inA.nChunk) ;
vCellPolygons.clear() ;
vCellPolygons3d.clear() ;
}
c = 0 ;
@@ -3247,15 +3220,14 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
//----------------------------------------------------------------------------
bool
Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, int& nPoly, INTVECTOR& vnParentChunk)
Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, int& nPoly, INTVECTOR& vnParentChunk, bool bForTriangulation)
{
// vettore dei poligoni ( loop) della cella nId
POLYLINEVECTOR vCellPolygons ;
POLYLINEVECTOR vCellPolygons3d ;
// costruisco i poligoni partendo dal vettore delle intersezioni
int nId = m_vnLeaves[nLeafId] ;
//PolyLine plTrimmedPoly ;
//PolyLine plTrimmedPoly3d ;
//capisco se sono in modalità ForTriangulation
// loop interni in una cella intersecata
int nChunkBiggestCW = -1 ;
@@ -3308,14 +3280,16 @@ Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATR
vCellPolygons.push_back( plInLoop) ;
vPolygons.push_back( vCellPolygons) ;
++ nPoly ;
plInLoop3d.AddUPoint( 0, m_mVert[nId][2]);
plInLoop3d.AddUPoint( 1, m_mVert[nId][3]);
plInLoop3d.AddUPoint( 2, m_mVert[nId][0]);
plInLoop3d.AddUPoint( 3, m_mVert[nId][1]);
vCellPolygons3d.push_back( plInLoop3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
vCellPolygons3d.clear() ;
plInLoop3d.Clear() ;
if ( bForTriangulation) {
plInLoop3d.AddUPoint( 0, m_mVert[nId][2]);
plInLoop3d.AddUPoint( 1, m_mVert[nId][3]);
plInLoop3d.AddUPoint( 2, m_mVert[nId][0]);
plInLoop3d.AddUPoint( 3, m_mVert[nId][1]);
vCellPolygons3d.push_back( plInLoop3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
vCellPolygons3d.clear() ;
plInLoop3d.Clear() ;
}
// imposto il chunk del loop CW più grande ( il primo che ho incontrato)
vnParentChunk.push_back( nChunkBiggestCW) ;
vCellPolygons.clear() ;
@@ -3328,12 +3302,15 @@ Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATR
int k = 0 ;
for ( Point3d ptInt : inA.vpt) {
plInLoop.AddUPoint( k, ptInt) ;
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptInt.x / SBZ_TREG_COEFF, ptInt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plInLoop3d.AddUPoint( k, pt3d) ;
if ( bForTriangulation) {
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptInt.x / SBZ_TREG_COEFF, ptInt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plInLoop3d.AddUPoint( k, pt3d) ;
}
++ k ;
}
plInLoop.Close() ;
plInLoop3d.Close() ;
if ( bForTriangulation)
plInLoop3d.Close() ;
bool bAdded = false ;
// se il loop è CW devo controllare in quale altro dei poligoni che ho già aggiunto è contenuto
if ( ! inA.bCCW) {
@@ -3343,9 +3320,11 @@ Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATR
for ( int r = 0 ; r < nPoly ; ++r) {
if ( IsPointInsidePolyLine( ptStart, vPolygons[nOtherPoly - r - 1][0], -0.01) && vnParentChunk[nPoly - r - 1] == inA.nChunk) {
vPolygons[nOtherPoly - r - 1].push_back( plInLoop) ;
vPolygons3d[nOtherPoly - r - 1].push_back( plInLoop3d) ;
plInLoop.Clear() ;
plInLoop3d.Clear() ;
if ( bForTriangulation) {
vPolygons3d[nOtherPoly - r - 1].push_back( plInLoop3d) ;
plInLoop3d.Clear() ;
}
bAdded = true ;
break ;
}
@@ -3354,17 +3333,20 @@ Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATR
if ( ! bAdded) {
vCellPolygons.push_back( plInLoop) ;
vPolygons.push_back( vCellPolygons) ;
vCellPolygons3d.push_back( plInLoop3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
++ nPoly ;
vnParentChunk.push_back( inA.nChunk) ;
plInLoop.Clear() ;
vCellPolygons.clear() ;
plInLoop3d.Clear() ;
vCellPolygons3d.clear() ;
if ( bForTriangulation) {
vCellPolygons3d.push_back( plInLoop3d) ;
vPolygons3d.push_back( vCellPolygons3d) ;
plInLoop3d.Clear() ;
vCellPolygons3d.clear() ;
}
++ nPoly ;
vnParentChunk.push_back( inA.nChunk) ;
}
plInLoop.Clear() ;
plInLoop3d.Clear() ;
if ( bForTriangulation)
plInLoop3d.Clear() ;
}
else
continue ;
@@ -3525,12 +3507,17 @@ Tree::AreSameEdge( int nEdge1, int nEdge2) const
bool
Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVertex3d, PolyLine& plTrimmedPoly, int& c, const Point3d& ptToAdd, PolyLine& plTrimmedPoly3d) const
{
//capisco se sono in modalità ForTriangulation
bool bForTriangulation = plTrimmedPoly3d.GetPointNbr() ;
// se è il primo punto della PolyLine lo aggiungo
if ( plTrimmedPoly.GetPointNbr() == 0) {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ;
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if ( bForTriangulation) {
Point3d pt3d ;
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
return true ;
}
@@ -3570,12 +3557,14 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
else
ptVert = ptToAdd ;
plTrimmedPoly.AddUPoint( c, ptVert) ;
Point3d pt3d ;
if ( nVert != -1)
pt3d = m_mVert.at(nId)[nVert] ;
else
m_pSrfBz->GetPointD1D2( ptVert.x, ptVert.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation){
Point3d pt3d ;
if ( nVert != -1)
pt3d = m_mVert.at(nId)[nVert] ;
else
m_pSrfBz->GetPointD1D2( ptVert.x, ptVert.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
return true ;
}
@@ -3587,17 +3576,20 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[0][t] ;
if ( ptIntermed.x > ptToAdd.x && ptIntermed.x < ptLast.x) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[0][t]) ;
if( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[0][t]) ;
++ c ;
}
}
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[1][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[1][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation){
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[1][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[1][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
// edge 1
@@ -3606,17 +3598,20 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[1][t] ;
if ( ptIntermed.y > ptToAdd.y && ptIntermed.y < ptLast.y) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[1][t]) ;
if( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[1][t]) ;
++ c ;
}
}
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[2][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[2][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation) {
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[2][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[2][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
// edge 2
@@ -3625,17 +3620,20 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[2][t] ;
if ( ptIntermed.x < ptToAdd.x && ptIntermed.x > ptLast.x) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[2][t]) ;
if( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[2][t]) ;
++ c ;
}
}
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[3][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[3][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation){
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[3][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[3][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
// edge 3
@@ -3644,33 +3642,40 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[3][t] ;
if ( ptIntermed.y < ptToAdd.y && ptIntermed.y > ptLast.y) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[3][t]) ;
if( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[3][t]) ;
++ c ;
}
}
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[0][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[0][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation) {
Point3d pt3d ;
if( ! AreSamePointApprox(ptToAdd, vEdgeVertex[0][0]))
m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
else
pt3d = vEdgeVertex3d[0][0] ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
// sono allineato con un lato, ma NON sono su un lato
// aggiungo e basta
else {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation) {
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
}
// non su un edge, quindi aggiungo e basta
else {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
if( bForTriangulation) {
Point3d pt3d ; m_pSrfBz->GetPointD1D2( ptToAdd.x / SBZ_TREG_COEFF, ptToAdd.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
++ c ;
}
return true ;