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

EgtGeomKernel 2.1k2 :

Browse Source 
- a SurfTriMesh aggiunta GetSurfClassification.
This commit is contained in:
Dario Sassi
2019-12-07 09:28:54 +00:00
parent 01cfe08fa9
commit d5a7192a85
3 changed files with 161 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SurfTriMeshBooleans.cpp
+157 -244
View File
@@ -27,6 +27,8 @@
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkGeoCollection.h"
#include "/EgtDev/Include/EGkPolygon3d.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include <algorithm>
using namespace std ;
@@ -1229,20 +1231,63 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
else {
POLYLINEVECTOR vPolygons ;
vPolygons.emplace_back( vplPolyVec[nLoop]) ;
if ( vbInOut[nLoop]) {
for ( int nL = 0 ; nL < int( vInnerLoop.size()) ; ++ nL) {
PolyLine CurLoop ;
for ( int nV = 0 ; nV < int( cvClosedChain[vInnerLoop[nL]].size()) ; ++ nV) {
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][nV].ptSt) ;
}
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][0].ptSt) ;
vPolygons.emplace_back( CurLoop) ;
for ( int nL = 0 ; nL < int( vInnerLoop.size()) ; ++ nL) {
PolyLine CurLoop ;
for ( int nV = 0 ; nV < int( cvClosedChain[vInnerLoop[nL]].size()) ; ++ nV) {
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][nV].ptSt) ;
}
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][0].ptSt) ;
vPolygons.emplace_back( CurLoop) ;
}
Polygon3d pgPol ;
pgPol.FromPolyLine( vPolygons[1]) ;
if ( trTria.GetN() * pgPol.GetVersN() > 0.) {
for ( int nL = 1 ; nL < int( vPolygons.size()) ; ++ nL) {
vPolygons[nL].Invert() ;
}
PNTVECTOR vPt ;
INTVECTOR vTr ;
if ( Triangulate().Make( vPolygons, vPt, vTr)) {
// Inserisco i nuovi triangoli
// Inserisco i nuovi triangoli
for ( int n = 0 ; n < int( vTr.size()) - 2 ; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] };
int nNewId[3] = { Surf.AddVertex(vPt[nNewTriaVertId[0]]),
Surf.AddVertex(vPt[nNewTriaVertId[1]]),
Surf.AddVertex(vPt[nNewTriaVertId[2]]) } ;
int nNewTriaNum = Surf.AddTriangle( nNewId) ;
if ( IsValidSvt( nNewTriaNum)) {
Surf.m_vTria[nNewTriaNum].nTempPart = -1 ;
bModif = true ;
}
}
}
for ( int nL = 1 ; nL < int( vPolygons.size()) ; ++ nL) {
vPolygons[nL].Invert() ;
if ( Triangulate().Make( vPolygons[nL], vPt, vTr)) {
// Inserisco i nuovi triangoli
for ( int n = 0 ; n < int( vTr.size()) - 2 ; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] } ;
int nNewId[3] = { Surf.AddVertex(vPt[nNewTriaVertId[0]]),
Surf.AddVertex(vPt[nNewTriaVertId[1]]),
Surf.AddVertex(vPt[nNewTriaVertId[2]]) } ;
int nNewTriaNum = Surf.AddTriangle( nNewId) ;
if ( IsValidSvt( nNewTriaNum)) {
Surf.m_vTria[nNewTriaNum].nTempPart = 1 ;
bModif = true ;
}
}
}
}
}
else {
PNTVECTOR vPt ;
INTVECTOR vTr ;
if ( Triangulate().Make( vPolygons, vPt, vTr)) {
// Inserisco i nuovi triangoli
for ( int n = 0 ; n < int( vTr.size()) - 2 ; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] } ;
int nNewId[3] = { Surf.AddVertex(vPt[nNewTriaVertId[0]]),
@@ -1259,67 +1304,21 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
for ( int nL = 1 ; nL < int( vPolygons.size()) ; ++ nL) {
vPolygons[nL].Invert() ;
if ( Triangulate().Make( vPolygons[nL], vPt, vTr)) {
// Inserisco i nuovi triangoli
for ( int n = 0 ; n < int(vTr.size()) - 2 ; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] } ;
int nNewId[3] = { Surf.AddVertex( vPt[nNewTriaVertId[0]]),
Surf.AddVertex( vPt[nNewTriaVertId[1]]),
Surf.AddVertex( vPt[nNewTriaVertId[2]]) } ;
int nNewTriaNum = Surf.AddTriangle( nNewId) ;
if (IsValidSvt( nNewTriaNum)) {
Surf.m_vTria[nNewTriaNum].nTempPart = - 1 ;
bModif = true ;
}
}
}
}
}
else {
for ( int nL = 0 ; nL < int( vInnerLoop.size()) ; ++ nL) {
PolyLine CurLoop ;
for ( int nV = 0 ; nV < int( cvClosedChain[vInnerLoop[nL]].size()) ; ++ nV) {
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][nV].ptSt) ;
}
CurLoop.AddUPoint( 0., cvClosedChain[vInnerLoop[nL]][0].ptSt) ;
CurLoop.Invert() ;
vPolygons.emplace_back( CurLoop) ;
}
PNTVECTOR vPt ;
INTVECTOR vTr ;
if ( Triangulate().Make( vPolygons, vPt, vTr)) {
// Inserisco i nuovi triangoli
for (int n = 0; n < int(vTr.size()) - 2; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] } ;
int nNewId[3] = { Surf.AddVertex( vPt[nNewTriaVertId[0]]),
Surf.AddVertex( vPt[nNewTriaVertId[1]]),
Surf.AddVertex( vPt[nNewTriaVertId[2]]) } ;
int nNewTriaNum = Surf.AddTriangle( nNewId) ;
if ( IsValidSvt( nNewTriaNum)) {
Surf.m_vTria[nNewTriaNum].nTempPart = 1 ;
bModif = true ;
}
}
}
for ( int nL = 1 ; nL < int( vPolygons.size()); ++ nL) {
vPolygons[nL].Invert() ;
if ( Triangulate().Make( vPolygons[nL], vPt, vTr)) {
// Inserisco i nuovi triangoli
// Inserisco i nuovi triangoli
for ( int n = 0 ; n < int( vTr.size()) - 2 ; n += 3) {
int nNewTriaVertId[3] = { vTr[n], vTr[n + 1], vTr[n + 2] } ;
int nNewId[3] = { Surf.AddVertex(vPt[nNewTriaVertId[0]]),
Surf.AddVertex(vPt[nNewTriaVertId[1]]),
Surf.AddVertex(vPt[nNewTriaVertId[2]]) } ;
int nNewTriaNum = Surf.AddTriangle( nNewId) ;
if (IsValidSvt( nNewTriaNum)) {
if ( IsValidSvt( nNewTriaNum)) {
Surf.m_vTria[nNewTriaNum].nTempPart = - 1 ;
bModif = true ;
}
}
}
}
}
}
}
vInnerLoop.resize( 0) ;
}
@@ -1327,6 +1326,40 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::AmbiguosTriangleHandler( TRIA3DVECTORMAP& Ambiguos, SurfTriMesh& Surf)
{
for ( auto it = Ambiguos.begin() ; it != Ambiguos.end() ; ++ it) {
Triangle3d trTria ;
GetTriangle( it->first, trTria) ;
trTria.Validate() ;
Point3d ptBar = ( trTria.GetP( 0) + trTria.GetP( 1) + trTria.GetP( 2)) / 3 ;
double dMinDist = DBL_MAX ;
int nTriaIndex = - 1 ;
for ( int nOthSurfT = 0 ; nOthSurfT < int( it->second.size()) ; ++ nOthSurfT) {
Triangle3d trOthSurfTria = it->second[nOthSurfT] ;
double dDot = ( ptBar - trOthSurfTria.GetP( 0)) * trOthSurfTria.GetN() ;
if ( abs( dDot) > EPS_SMALL) {
DistPointTriangle DistCalc( ptBar, trOthSurfTria) ;
double dDist ;
DistCalc.GetDist( dDist) ;
if ( dDist < dMinDist) {
nTriaIndex = nOthSurfT ;
dMinDist = dDist ;
}
}
}
if ( nTriaIndex != -1) {
Triangle3d trOthSurfTria = it->second[nTriaIndex] ;
trOthSurfTria.Validate() ;
double dDot = ( ptBar - trOthSurfTria.GetP( 0)) * trOthSurfTria.GetN() ;
Surf.m_vTria[it->first].nTempPart = ( dDot < 0 ? 1 : -1) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
@@ -1350,6 +1383,9 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
m_vTria[nTA].nTempPart = 0 ;
for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB)
SurfB.m_vTria[nTB].nTempPart = 0 ;
// Resetto e ricalcolo la HashGrid della superficie B
SurfB.ResetHashGrids3d() ;
SurfB.VerifyHashGrids3d() ;
for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
// Se il triangolo A non è valido, continuo
Triangle3d trTriaA ;
@@ -1358,11 +1394,14 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
// Box del triangolo A
BBox3d b3dTriaA ;
trTriaA.GetLocalBBox( b3dTriaA) ;
// Recupero i triangoli di B che interferiscono col box del triangolo di A
INTVECTOR vNearTria ;
SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
bool bNewTriaA = true ;
for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
for ( int nTB = 0 ; nTB < int( vNearTria.size()) ; ++ nTB) {
// Se il triangolo B non è valido, continuo
Triangle3d trTriaB ;
if ( ! ( SurfB.GetTriangle( nTB, trTriaB) && trTriaB.Validate( true)))
if ( ! ( SurfB.GetTriangle( vNearTria[nTB], trTriaB) && trTriaB.Validate( true)))
continue ;
// Box del triangolo B
BBox3d b3dTriaB ;
@@ -1416,14 +1455,14 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
// Salvo intersezione per superficie B
bool bIntOnEndgeB = false ;
if ( ! ( nIntType == ITTTS_EDGE_EDGE_SEG || nIntType == ITTTS_INT_EDGE)) {
auto itB = LineMapB.find( nTB) ;
auto itB = LineMapB.find( vNearTria[nTB]) ;
if ( itB != LineMapB.end()) {
itB->second.emplace_back( CurInters) ;
}
else {
Chain chTemp ;
chTemp.emplace_back( CurInters) ;
LineMapB.emplace( nTB, chTemp) ;
LineMapB.emplace( vNearTria[nTB], chTemp) ;
}
}
else
@@ -1455,7 +1494,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
}
}
if ( nSegMaxDist >= 0) {
SurfB.m_vTria[nTB].nTempPart = ( ( trTriaB.GetP( nSegMaxDist) - trTriaA.GetP( 0)) * trTriaA.GetN() < - EPS_SMALL ? 1 : - 1) ;
SurfB.m_vTria[vNearTria[nTB]].nTempPart = ( ( trTriaB.GetP( nSegMaxDist) - trTriaA.GetP( 0)) * trTriaA.GetN() < - EPS_SMALL ? 1 : - 1) ;
}
}
// Intersezione edge-edge
@@ -1469,11 +1508,11 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
else {
itA->second.emplace_back( trTriaB) ;
}
auto itB = AmbiguosB.find( nTB) ;
auto itB = AmbiguosB.find( vNearTria[nTB]) ;
if ( itB == AmbiguosB.end()) {
TRIA3DVECTOR vVecTriaA ;
vVecTriaA.emplace_back( trTriaA) ;
AmbiguosB.emplace( nTB, vVecTriaA) ;
AmbiguosB.emplace( vNearTria[nTB], vVecTriaA) ;
}
else {
itB->second.emplace_back( trTriaA) ;
@@ -1578,58 +1617,8 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
// Se c'è stata una ritriangolazione di almeno un triangolo, NON siamo nel caso di tutto dentro o tutto fuori.
// Studio i triangoli ambigui.
if ( bRetriangulated) {
for ( auto it = AmbiguosA.begin() ; it != AmbiguosA.end() ; ++ it) {
Triangle3d trTriaA ;
GetTriangle( it->first, trTriaA) ;
trTriaA.Validate() ;
Point3d ptBarA = ( trTriaA.GetP( 0) + trTriaA.GetP( 1) + trTriaA.GetP( 2)) / 3 ;
double dMinDist = DBL_MAX ;
int nTriaIndex = - 1 ;
for ( int nTB = 0 ; nTB < int( it->second.size()) ; ++ nTB) {
Triangle3d trTriaB = it->second[nTB] ;
double dDot = ( ptBarA - trTriaB.GetP( 0)) * trTriaB.GetN() ;
if ( abs( dDot) > EPS_SMALL) {
DistPointTriangle DistCalc( ptBarA, trTriaB) ;
double dDist ;
DistCalc.GetDist( dDist) ;
if ( dDist < dMinDist) {
nTriaIndex = nTB ;
dMinDist = dDist ;
}
}
}
if ( nTriaIndex != - 1) {
Triangle3d trTriaB = it->second[nTriaIndex] ;
trTriaB.Validate() ;
double dDot = ( ptBarA - trTriaB.GetP( 0)) * trTriaB.GetN() ;
m_vTria[it->first].nTempPart = ( dDot < 0 ? 1 : - 1) ;
}
}
for ( auto it = AmbiguosB.begin() ; it != AmbiguosB.end() ; ++ it) {
Triangle3d trTriaB ;
SurfB.GetTriangle( it->first, trTriaB) ;
Point3d ptBarB = ( trTriaB.GetP( 0) + trTriaB.GetP( 1) + trTriaB.GetP( 2)) / 3 ;
double dMinDist = DBL_MAX ;
int nTriaIndex = - 1 ;
for ( int nTA = 0 ; nTA < int( it->second.size()) ; ++ nTA) {
Triangle3d trTriaA = it->second[nTA] ;
double dDot = ( ptBarB - trTriaA.GetP( 0)) * trTriaA.GetN() ;
if ( abs(dDot) > EPS_SMALL) {
DistPointTriangle DistCalc( ptBarB, trTriaA);
double dDist ;
DistCalc.GetDist( dDist) ;
if ( dDist < dMinDist) {
nTriaIndex = nTA ;
dMinDist = dDist ;
}
}
}
if ( nTriaIndex != - 1) {
Triangle3d trTriaA = it->second[nTriaIndex] ;
double dDot = ( ptBarB - trTriaA.GetP( 0)) * trTriaA.GetN() ;
SurfB.m_vTria[it->first].nTempPart = ( dDot < 0 ? 1 : -1) ;
}
}
AmbiguosTriangleHandler( AmbiguosA, *this) ;
AmbiguosTriangleHandler( AmbiguosB, SurfB) ;
}
bool bContinue = true ;
@@ -1639,7 +1628,11 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
// Triangoli sovrapposti
if ( bContinue) {
int nTriaNumA = GetTriangleSize() ;
int nTriaNumB = SurfB.GetTriangleSize() ;
// int nTriaNumB = SurfB.GetTriangleSize() ;
// Resetto e ricalcolo la HashGrid della superficie B
SurfB.ResetHashGrids3d() ;
SurfB.VerifyHashGrids3d() ;
for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
// Se il triangolo A non è valido, continuo
Triangle3d trTriaA ;
@@ -1648,11 +1641,14 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
// Box del triangolo A
BBox3d b3dTriaA ;
trTriaA.GetLocalBBox( b3dTriaA) ;
// Recupero i triangoli di B che interferiscono col box del triangolo di A
INTVECTOR vNearTria ;
SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
bool bNewTriaA = true ;
for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
for ( int nTB = 0 ; nTB < int( vNearTria.size()) ; ++ nTB) {
// Se il triangolo B non è valido, continuo
Triangle3d trTriaB ;
if ( ! ( SurfB.GetTriangle( nTB, trTriaB) && trTriaB.Validate( true)))
if ( ! ( SurfB.GetTriangle( vNearTria[nTB], trTriaB) && trTriaB.Validate( true)))
continue ;
// Box del triangolo B
BBox3d b3dTriaB ;
@@ -1667,7 +1663,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
if ( nIntTypeAB == ITTTS_OVERLAPS) {
bool bInvertB = trTriaA.GetN() * trTriaB.GetN() < 0. ;
m_vTria[nTA].nTempPart = ( bInvertB ? -2 : 2) ;
SurfB.m_vTria[nTB].nTempPart = ( bInvertB ? - 2 : 2) ;
SurfB.m_vTria[vNearTria[nTB]].nTempPart = ( bInvertB ? - 2 : 2) ;
}
}
}
@@ -1751,7 +1747,7 @@ SurfTriMesh::RemoveTJunction( void)
double dProj = ( ptVert - ptSegSt) * vtSeg ;
double dOrt = ( ( ptVert - ptSegSt) - dProj * vtSeg).SqLen() ;
if ( dProj > EPS_SMALL && dProj < dSegLen - EPS_SMALL &&
dOrt < EPS_SMALL * EPS_SMALL) {
dOrt < SQ_EPS_TRIA_H) {
if ( bNewBaseSeg) {
IndexesMatrix.emplace_back() ;
bNewBaseSeg = false ;
@@ -1849,125 +1845,6 @@ SurfTriMesh::RemoveTJunction( void)
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::MarchAlongFacetLoopForTJunc( int nT, int nV, int nTimeStamp, TJuncLoop& TJLoop) const
{
// Mi muovo lungo il loop, un triangolo alla volta
bool bEnd = false ;
while ( ! bEnd) {
if ( ! MarchOneFacetTriaForTJunc( nT, nV, nTimeStamp, TJLoop, bEnd))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::MarchOneFacetTriaForTJunc( int& nT, int& nV, int nTimeStamp, TJuncLoop& TJLoop, bool& bEnd) const
{
// Verifico esistenza triangolo adiacente, sul lato dopo il vertice
if ( m_vTria[nT].nIdAdjac[nV] == SVT_NULL)
return false ;
// Indice del triangolo adiacente
int nAdjT = m_vTria[nT].nIdAdjac[nV] ;
// Recupero il suo lato di adiacenza
int nAdjS = SVT_NULL ;
for ( int i = 0 ; i < 3 ; ++ i) {
if ( m_vTria[nAdjT].nIdAdjac[i] == nT) {
nAdjS = i ;
break ;
}
}
if ( nAdjS == SVT_NULL)
return false ;
// Vertice di fine adiacenza e indice del successivo lato
int nAdjV = Next( nAdjS) ;
// Verifico se il lato successivo è un bordo
int nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
if ( nNextT == SVT_NULL) {
// Se già recuperato
if ( m_vTria[nAdjT].nTemp == nTimeStamp) {
bEnd = true ;
return true ;
}
// Dichiaro triangolo analizzato
m_vTria[nAdjT].nTemp = nTimeStamp ;
// Aggiungo il lato al loop
TJLoop.emplace_back() ;
TJLoop.back().nTriaId = nAdjT ;
TJLoop.back().nEdge = nAdjV ;
// Verifico anche il successivo
nAdjV = Next( nAdjV) ;
nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
if ( nNextT == SVT_NULL) {
// Aggiungo il lato al loop
TJLoop.emplace_back() ;
TJLoop.back().nTriaId = nAdjT ;
TJLoop.back().nEdge = nAdjV ;
nAdjV = Next(nAdjV);
}
}
// Devo passare al triangolo adiacente
nT = nAdjT ;
nV = nAdjV ;
return true ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::GetForwardAdjTriaSharingVertex( int& nTria, int& nVertInTria) const
{
// Verifico validità della posizione del vertice nel triangolo
if ( nVertInTria < 0 || nVertInTria > 2)
return false ;
int nVert = m_vTria[nTria].nIdVert[nVertInTria] ;
// Verifico esistenza del vertice
if ( nVert < 0 || nVert >= GetVertexSize() || m_vVert[nVert].nIdTria == SVT_DEL)
return false ;
// Verifico esistenza del triangolo
if ( nTria < 0 || nTria >= GetTriangleSize() || m_vTria[nTria].nIdVert[0] == SVT_DEL)
return false ;
// Trovo triangolo adiacente che condivide il vertice
nTria = m_vTria[nTria].nIdAdjac[nVertInTria] ;
if ( nTria < 0 || nTria >= GetTriangleSize())
return false ;
// Trovo posizione del vertice nel triangolo adiacente
nVertInTria = - 1 ;
for ( int n = 0 ; n < 3 ; ++ n) {
if ( m_vTria[nTria].nIdVert[n] == nVert)
nVertInTria = n ;
}
return ( nVertInTria != - 1) ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::GetBackwardAdjTriaSharingVertex( int& nTria, int& nVertInTria) const
{
// Verifico validità della posizione del vertice nel triangolo
if ( nVertInTria < 0 || nVertInTria > 2)
return false ;
int nVert = m_vTria[nTria].nIdVert[nVertInTria] ;
// Verifico esistenza del vertice
if ( nVert < 0 || nVert >= GetVertexSize() || m_vVert[nVert].nIdTria == SVT_DEL)
return false ;
// Verifico esistenza del triangolo
if ( nTria < 0 || nTria >= GetTriangleSize() || m_vTria[nTria].nIdVert[0] == SVT_DEL)
return false ;
// Trovo triangolo adiacente che condivide il vertice
nTria = m_vTria[nTria].nIdAdjac[( nVertInTria + 2) % 3] ;
if ( nTria < 0 || nTria >= GetTriangleSize())
return false ;
// Trovo posizione del vertice nel triangolo adiacente
nVertInTria = -1 ;
for ( int n = 0 ; n < 3 ; ++ n) {
if ( m_vTria[nTria].nIdVert[n] == nVert)
nVertInTria = n ;
}
return ( nVertInTria != - 1) ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::Add( const ISurfTriMesh& Other)
@@ -2024,7 +1901,7 @@ SurfTriMesh::Intersect( const ISurfTriMesh& Other)
}
if ( ! AdjustVertices() || ! DoCompacting())
return false ;
RemoveTJunction() ;
RemoveTJunction();
return ( AdjustVertices() && DoCompacting()) ;
}
@@ -2059,7 +1936,43 @@ SurfTriMesh::Subtract( const ISurfTriMesh& Other)
return ( AdjustVertices() && DoCompacting()) ;
}
//----------------------------------------------------------------------------
bool
SurfTriMesh::GetSurfClassification( const ISurfTriMesh& ClassifierSurf,
INTVECTOR& vTriaIn, INTVECTOR& vTriaOut, INTVECTOR& vTriaOnP, INTVECTOR& vTriaOnM, INTVECTOR& vTriaIndef)
{
// Le superfici devono essere valide
if ( ! IsValid() || ! ClassifierSurf.IsValid())
return false ;
SurfTriMesh SurfC ;
SurfC.CopyFrom( &ClassifierSurf) ;
IntersectTriMeshTriangle( SurfC) ;
IdentifyParts() ;
int nTriaNum = GetTriangleSize() ;
for ( int nT = 0 ; nT < nTriaNum ; ++ nT) {
if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
continue ;
switch ( m_vTria[nT].nTempPart) {
case -2 :
vTriaOnM.push_back( nT) ;
break ;
case -1 :
vTriaOut.push_back( nT) ;
break ;
case 0 :
vTriaIndef.push_back( nT) ;
break ;
case 1 :
vTriaIn.push_back( nT) ;
break ;
case 2 :
vTriaOnP.push_back( nT) ;
break ;
}
}
return true ;
}
///////////////////////// DEBUG /////////////////////////////////////////////////////////////////////////////////////////////////
//if ( ( AreSamePointApprox(trTriaA.GetP(0), Point3d(20, 40, 46)) &&
@@ -2124,7 +2037,7 @@ SurfTriMesh::Subtract( const ISurfTriMesh& Other)
// // Se triangolo non visitato
// if ( m_vTria[nT].nTemp == 0) {
// m_vTria[nT].nTemp = 1 ;
// std::unordered_set<int> TriaIndexSet ;// devi usare stack
// unordered_set<int> TriaIndexSet ;// devi usare stack
// TriaIndexSet.emplace( nT) ;
// while ( ! TriaIndexSet.empty()) {
//