From d5a7192a85688b596d6f994b3fe604d509cfa0c0 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Sat, 7 Dec 2019 09:28:54 +0000 Subject: [PATCH] EgtGeomKernel 2.1k2 : - a SurfTriMesh aggiunta GetSurfClassification. --- EgtGeomKernel.rc | Bin 11718 -> 11718 bytes SurfTriMesh.h | 9 +- SurfTriMeshBooleans.cpp | 401 ++++++++++++++++------------------------ 3 files changed, 161 insertions(+), 249 deletions(-) diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index fdba162e21ec0227ad598a71f5dc8f99a170a15f..6bdc57698e299d187972e7ada67cabdbdd1c14e0 100644 GIT binary patch delta 110 zcmX>WeJpyzA2vp#&G-4vGfl1&(wY2&Q;pGRvZAo=W*@FeEMOU1X1ItOWeJpyzA2vqA&G-4vGfl1&(wY2&Q;pGZvZAo=W*@FeEMOU1X1ItO 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 TriaIndexSet ;// devi usare stack +// unordered_set TriaIndexSet ;// devi usare stack // TriaIndexSet.emplace( nT) ; // while ( ! TriaIndexSet.empty()) { //