diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index d8e9aad..ee7a78e 100644 Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ diff --git a/SurfTriMesh.cpp b/SurfTriMesh.cpp index 7260a87..d688c4e 100644 --- a/SurfTriMesh.cpp +++ b/SurfTriMesh.cpp @@ -489,6 +489,52 @@ SurfTriMesh::GetNextTriangle( int nId, Triangle3d& Tria) const return nId ; } +//---------------------------------------------------------------------------- +bool +SurfTriMesh::GetTriangle( int nId, Triangle3dEx& Tria) const +{ + // verifico esistenza del triangolo + if ( nId < 0 || nId >= GetTriangleSize() || m_vTria[nId].nIdVert[0] == SVT_DEL) + return false ; + // recupero i dati + Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP, + m_vVert[m_vTria[nId].nIdVert[1]].ptP, + m_vVert[m_vTria[nId].nIdVert[2]].ptP, + m_vTria[nId].vtN) ; + GetTriangleBoundaryEdges( nId, const_cast( Tria.GetTriFlags())) ; + GetTriangleSmoothNormals( nId, const_cast( Tria.GetTriNormals())) ; + return true ; +} + +//---------------------------------------------------------------------------- +int +SurfTriMesh::GetFirstTriangle( Triangle3dEx& Tria) const +{ + return GetNextTriangle( SVT_NULL, Tria) ; +} + +//---------------------------------------------------------------------------- +int +SurfTriMesh::GetNextTriangle( int nId, Triangle3dEx& Tria) const +{ + // cerco il primo successivo valido + do { + nId ++ ; + } while ( nId < GetTriangleSize() && m_vTria[nId].nIdVert[0] == SVT_DEL) ; + // se oltrepassata fine + if ( nId >= GetTriangleSize()) + return SVT_NULL ; + // recupero i dati + Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP, + m_vVert[m_vTria[nId].nIdVert[1]].ptP, + m_vVert[m_vTria[nId].nIdVert[2]].ptP, + m_vTria[nId].vtN) ; + GetTriangleBoundaryEdges( nId, const_cast( Tria.GetTriFlags())) ; + GetTriangleSmoothNormals( nId, const_cast( Tria.GetTriNormals())) ; + // ritorno indice triangolo corrente + return nId ; +} + //---------------------------------------------------------------------------- int SurfTriMesh::GetAllTriaAroundVertex( int nV, INTVECTOR& vT, bool& bCirc) const diff --git a/SurfTriMesh.h b/SurfTriMesh.h index 97b13f0..37fc9b3 100644 --- a/SurfTriMesh.h +++ b/SurfTriMesh.h @@ -1,7 +1,7 @@ //---------------------------------------------------------------------------- -// EgalTech 2014-2014 +// EgalTech 2014-2019 //---------------------------------------------------------------------------- -// File : SurfTriMesh.h Data : 26.03.14 Versione : 1.5c9 +// File : SurfTriMesh.h Data : 12.02.19 Versione : 2.1b2 // Contenuto : Dichiarazione della classe Superficie TriMesh. // // @@ -161,6 +161,9 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW bool GetTriangle( int nId, Triangle3d& Tria) const override ; int GetFirstTriangle( Triangle3d& Tria) const override ; int GetNextTriangle( int nId, Triangle3d& Tria) const override ; + bool GetTriangle( int nId, Triangle3dEx& Tria) const override ; + int GetFirstTriangle( Triangle3dEx& Tria) const override ; + int GetNextTriangle( int nId, Triangle3dEx& Tria) const override ; int GetAllTriaAroundVertex( int nV, INTVECTOR& vT, bool& bCirc) const override ; bool GetVertexSmoothNormal( int nV, int nT, Vector3d& vtN) const override ; bool GetTriangleBoundaryEdges( int nId, TriFlags3d& TFlags) const override ; diff --git a/VolZmap.cpp b/VolZmap.cpp index 2227ed6..e8cfd5b 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -142,7 +142,7 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc) m_BlockUpdatingCounter = vzmSrc.m_BlockUpdatingCounter ; m_InterBlockVox = vzmSrc.m_InterBlockVox ; m_InterBlockOriginalSharpTria = vzmSrc.m_InterBlockOriginalSharpTria ; - m_InterBlockToBeFlippedSharpTria = vzmSrc.m_InterBlockToBeFlippedSharpTria ; + m_InterBlockSharpTria = vzmSrc.m_InterBlockSharpTria ; m_BlockSharpTria = vzmSrc.m_BlockSharpTria ; m_BlockSmoothTria = vzmSrc.m_BlockSmoothTria ; m_BlockBigTria = vzmSrc.m_BlockBigTria ; @@ -393,7 +393,7 @@ VolZmap::Load( NgeReader& ngeIn) // per triangoli di feature di frontiera tra blocchi m_InterBlockVox.resize( m_nNumBlock) ; m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; - m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_InterBlockSharpTria.resize( m_nNumBlock) ; m_BlockSharpTria.resize( m_nNumBlock) ; m_BlockSmoothTria.resize( m_nNumBlock) ; m_BlockBigTria.resize( m_nNumBlock) ; diff --git a/VolZmap.h b/VolZmap.h index 81d57bf..9ef0960 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -75,12 +75,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ; bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ; bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex) override ; - bool GetAllTriangles( TRIA3DEXLIST& lstTria) const override ; int GetBlockCount( void) const override ; + int GetBlockUpdatingCounter( int nBlock) const override ; + bool GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const override ; bool GetVolume( double& dVol) const override ; int GetPartCount( void) const override ; bool GetPartVolume( int nPart, double& dVol) const override ; - bool GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLISTVECTOR& vLstTria) const override ; bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ; bool SetTolerances( double dLinTol, double dAngTolDeg = 90) override ; bool SetStdTool( const std::string& sToolName, double dH, double dR, double dCornR, int nFlag) override ; @@ -189,8 +189,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ, const Vector3d& vtZ, const Vector3d& vtNorm, int nBlock) const ; bool ProcessCell( int nGrid, int nCellI, int nCellJ, const Plane3d& plPlane, std::vector& vLine) const ; - bool UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const ; - bool UpdateSingleMapGraphics( INTVECTOR& nModifiedBlocks) const ; + bool UpdateSingleMapGraphics( void) const ; + bool UpdateTripleMapGraphics( void) const ; bool ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const ; bool RegulateFeaturesChain( std::vector& vVecVox) const ; bool CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVox) const ; @@ -396,7 +396,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW mutable std::vector m_InterBlockVox ; mutable SharpTriaMatrix m_InterBlockOriginalSharpTria ; - mutable SharpTriaMatrix m_InterBlockToBeFlippedSharpTria ; + mutable SharpTriaMatrix m_InterBlockSharpTria ; mutable SharpTriaMatrix m_BlockSharpTria ; mutable SmoothTriaMatrix m_BlockSmoothTria ; mutable std::vector m_BlockBigTria ; diff --git a/VolZmapCalculus.cpp b/VolZmapCalculus.cpp index aebd0f6..efd2384 100644 --- a/VolZmapCalculus.cpp +++ b/VolZmapCalculus.cpp @@ -409,9 +409,11 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn return true ; } - // Se la grafica non è aggiornata la ricalcolo - INTVECTOR nModifiedBlocks ; - UpdateTripleMapGraphics( nModifiedBlocks) ; + // Lancio eventuale aggiornamento pendente della grafica + if ( m_nMapNum == 1) + UpdateSingleMapGraphics() ; + else + UpdateTripleMapGraphics() ; // Determino il voxel di partenza int nVoxI, nVoxJ, nVoxK ; @@ -420,7 +422,7 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn return false ; } - // Incrementi degli indici per sguire la retta + // Incrementi degli indici per seguire la retta int nDeltaI = ( vtD.x > 0 ? 1 : ( vtD.x < 0 ? - 1 : 0)) ; int nDeltaJ = ( vtD.y > 0 ? 1 : ( vtD.y < 0 ? - 1 : 0)) ; int nDeltaK = ( vtD.z > 0 ? 1 : ( vtD.z < 0 ? - 1 : 0)) ; @@ -493,13 +495,13 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn int nCurBlockN ; GetBlockNFromIJK( nCurBlockIJK, nCurBlockN) ; // Triangoli sharp fra blocchi - for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN].size()) ; ++ nBlVx) { - if ( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] && - m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] && - m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) { - for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) { - for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) { - Triangle3d CurrTria = m_InterBlockToBeFlippedSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ; + for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockSharpTria[nCurBlockN].size()) ; ++ nBlVx) { + if ( m_InterBlockSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] && + m_InterBlockSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] && + m_InterBlockSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) { + for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) { + for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) { + Triangle3d CurrTria = m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ; Point3d ptLineTria1, ptLineTria2 ; // Studio dell'intersezione della retta con il triangolo corrente int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; @@ -611,30 +613,6 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn } } } - // Ciclo sui triangoli dei voxel - //for ( auto it = lstTria.begin() ; it != lstTria.end() ; ++it ) { - // // Triangolo corrente e suoi punti di intersezione con la retta - // const Triangle3d& CurrTria = *it ; - // Point3d ptLineTria1, ptLineTria2 ; - // // Studio dell'intersezione della retta con il triangolo corrente - // int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ; - // // Se non ci sono intersezioni passo al prossimo triangolo - // if ( nIntType == ILTT_NO) - // continue ; - // // se altrimenti c'è una sola intersezione - // else if ( nIntType == ILTT_VERT || - // nIntType == ILTT_EDGE || - // nIntType == ILTT_IN) { - // vInt.emplace_back( ( ptLineTria1 - ptP) * vtD, vtD * CurrTria.GetN()) ; - // } - // // altrimenti ci sono due intersezioni - // else { - // double dP1 = ( ptLineTria1 - ptP) * vtD ; - // double dP2 = ( ptLineTria2 - ptP) * vtD ; - // double dD = vtD * CurrTria.GetN() ; - // vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ; - // } - //} // Ordino le intersezioni in base al parametro distanza con segno da ptP sort( vInt.begin(), vInt.end(), diff --git a/VolZmapCreation.cpp b/VolZmapCreation.cpp index f38c9c9..f3205ba 100644 --- a/VolZmapCreation.cpp +++ b/VolZmapCreation.cpp @@ -146,7 +146,7 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; - m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_InterBlockSharpTria.resize( m_nNumBlock) ; m_BlockSharpTria.resize( m_nNumBlock) ; m_BlockSmoothTria.resize( m_nNumBlock) ; m_BlockBigTria.resize( m_nNumBlock) ; @@ -457,7 +457,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; - m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_InterBlockSharpTria.resize( m_nNumBlock) ; m_BlockSharpTria.resize( m_nNumBlock) ; m_BlockSmoothTria.resize( m_nNumBlock) ; m_BlockBigTria.resize( m_nNumBlock) ; @@ -660,7 +660,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex // Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel m_InterBlockVox.resize( m_nNumBlock) ; m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ; - m_InterBlockToBeFlippedSharpTria.resize( m_nNumBlock) ; + m_InterBlockSharpTria.resize( m_nNumBlock) ; m_BlockSharpTria.resize( m_nNumBlock) ; m_BlockSmoothTria.resize( m_nNumBlock) ; m_BlockBigTria.resize( m_nNumBlock) ; diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp index 0c6dae9..3eee1d6 100644 --- a/VolZmapGraphics.cpp +++ b/VolZmapGraphics.cpp @@ -461,130 +461,141 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con } } -//---------------------------------------------------------------------------- -bool -VolZmap::GetAllTriangles( TRIA3DEXLIST& lstTria) const -{ - INTVECTOR nModifiedBlocks ; - TRIA3DEXLISTVECTOR vLstTria ; - if ( ! GetTriangles( true, nModifiedBlocks, vLstTria)) - return false ; - lstTria.clear() ; - for ( int i = 0 ; i < int( vLstTria.size()) ; ++ i) { - lstTria.splice( lstTria.end(), vLstTria[i]) ; - } - - return true ; -} - //---------------------------------------------------------------------------- bool -VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DEXLISTVECTOR& vLstTria) const +VolZmap::GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const { - // Caso di singola mappa + // Dexel (singola mappa) if ( m_nMapNum == 1) { - - nModifiedBlocks.resize( m_nNumBlock) ; - vLstTria.reserve( m_nNumBlock) ; - - UpdateSingleMapGraphics( nModifiedBlocks) ; - - // Se richiesti tutti, dichiaro tutti modificati - if ( bAllBlocks) { - for ( int i = 0 ; i < m_nNumBlock ; ++ i) - nModifiedBlocks[i] = i ; - } - - for ( int t = 0 ; t < m_nNumBlock ; ++ t) { - if ( nModifiedBlocks[t] >= 0) { - vLstTria.emplace_back() ; - for ( int tDx = 0 ; tDx < int( m_SingleMapTria[t].size()) ; ++ tDx) - vLstTria.back().emplace_back( m_SingleMapTria[t][tDx]) ; - } - } + // se il blocco non esiste, errore + if ( nBlock < 0 || nBlock > m_nNumBlock - 1) + return false ; + // lancio eventuale aggiornamento pendente della grafica + UpdateSingleMapGraphics() ; + // copio i triangoli + vTria = m_SingleMapTria[nBlock] ; + return true ; } - // Caso con tre mappe + // Tridexel (tre mappe) else { - - UpdateTripleMapGraphics( nModifiedBlocks) ; - - // Se richiesti tutti, dichiaro tutti modificati - if ( bAllBlocks) { - for ( int i = 0 ; i < m_nNumBlock + 1 ; ++ i) - nModifiedBlocks[i] = i ; - } - - // Alloco lo spazio - vLstTria.reserve( m_nNumBlock + 1) ; - - // Calcolo i triangoli sui blocchi - for ( int t = 0 ; t < m_nNumBlock ; ++ t) { - // Se il blocco è stato aggiornato - if ( nModifiedBlocks[t] >= 0) { - vLstTria.emplace_back() ; - // Copio i triangoli nella lista - for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[t].size()) ; ++ nVx) { - for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[t][nVx].vTria.size()) ; ++ nTr) { - vLstTria.back().emplace_back( m_BlockSmoothTria[t][nVx].vTria[nTr]) ; + // se il blocco non esiste, errore + if ( nBlock < 0 || nBlock > ( m_nNumBlock + 1) - 1) + return false ; + // lancio eventuale aggiornamento pendente della grafica + UpdateTripleMapGraphics() ; + // copio i triangoli del blocco + if ( nBlock != m_nNumBlock) { + vTria.clear() ; + vTria.reserve( 10000) ; + // triangoli smooth + for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[nBlock].size()) ; ++ nVx) { + for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[nBlock][nVx].vTria.size()) ; ++ nTr) + vTria.emplace_back( m_BlockSmoothTria[nBlock][nVx].vTria[nTr]) ; + } + // triangoli grandi piatti + for ( int tBl = 0 ; tBl < int( m_BlockBigTria[nBlock].size()) ; ++ tBl) { + vTria.emplace_back( m_BlockBigTria[nBlock][tBl]) ; + } + // triangoli di feature nel blocco (ciclo sui voxel del blocco) + for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[nBlock].size()) ; ++ t1) { + // ciclo sulle componenti connesse del voxel + for ( int t2 = 0 ; t2 < int( m_BlockSharpTria[nBlock][t1].vCompoTria.size()) ; ++ t2) { + // ciclo sui triangoli delle componenti connesse + for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[nBlock][t1].vCompoTria[t2].size()) ; ++ t3) { + // aggiungo triangolo alla lista + vTria.emplace_back( m_BlockSharpTria[nBlock][t1].vCompoTria[t2][t3]) ; } } } } - - // Inserisco i triangoli grandi piatti - for ( int t = 0 ; t < m_nNumBlock ; ++ t) { - if ( nModifiedBlocks[t] >= 0) { - for ( int tBl = 0 ; tBl < int( m_BlockBigTria[t].size()) ; ++ tBl) { - vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockBigTria[t][tBl]) ; - } - } - } - - // Inserisco in lista i triangoli di feature derivanti dai blocchi - for ( int t = 0 ; t < m_nNumBlock ; ++ t) { - if ( nModifiedBlocks[t] >= 0) { - // ciclo sui voxel del blocco - for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[t].size()) ; ++ t1) { - // ciclo sulle componenti connesse del voxel - for ( int t2 = 0 ; t2 < int( m_BlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { - // ciclo sui triangoli delle componenti connesse - for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { - // aggiungo triangolo alla lista - vLstTria[nModifiedBlocks[t]].emplace_back( m_BlockSharpTria[t][t1].vCompoTria[t2][t3]) ; - } - } - } - } - } - - // Inserisco in lista i triangoli di frontiera tra feature di blocchi diversi - if ( nModifiedBlocks[m_nNumBlock] >= 0) { - vLstTria.resize( vLstTria.size() + 1) ; - int nPos = int( vLstTria.size()) - 1 ; - for ( int t = 0 ; t < int( m_InterBlockToBeFlippedSharpTria.size()) ; ++ t) { - for ( int t1 = 0 ; t1 < int( m_InterBlockToBeFlippedSharpTria[t].size()) ; ++ t1) { - for ( int t2 = 0 ; t2 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { - for ( int t3 = 0 ; t3 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { - if ( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { + // blocco speciale aggiunto per i triangoli feature a cavallo dei blocchi + else { + vTria.clear() ; + vTria.reserve( 1000) ; + for ( int t = 0 ; t < int( m_InterBlockSharpTria.size()) ; ++ t) { + for ( int t1 = 0 ; t1 < int( m_InterBlockSharpTria[t].size()) ; ++ t1) { + for ( int t2 = 0 ; t2 < int( m_InterBlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { + for ( int t3 = 0 ; t3 < int( m_InterBlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { + if ( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { // aggiungo triangolo alla lista - vLstTria[nPos].emplace_back( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3]) ; + vTria.emplace_back( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3]) ; } } } } } } + return true ; } - - return true ; } //---------------------------------------------------------------------------- int VolZmap::GetBlockCount( void) const { - return m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1) ; + return ( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1)) ; +} + +//---------------------------------------------------------------------------- +int +VolZmap::GetBlockUpdatingCounter( int nBlock) const +{ + // se il blocco non esiste, errore + if ( nBlock < 0 || nBlock >= int( m_BlockUpdatingCounter.size())) + return -1 ; + // Lancio eventuale aggiornamento pendente della grafica + if ( m_nMapNum == 1) + UpdateSingleMapGraphics() ; + else + UpdateTripleMapGraphics() ; + // restituisco il suo indice di aggiornamento + return m_BlockUpdatingCounter[nBlock] ; +} + +//---------------------------------------------------------------------------- +bool +VolZmap::UpdateSingleMapGraphics( void) const +{ + const int MAX_DIM_CHUNK = 128 ; + + // Ciclo sui blocchi + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { + + // Se il blocco deve essere aggiornato, eseguo + if ( m_BlockToUpdate[t]) { + + m_SingleMapTria[t].clear() ; + + // Calcolo posizione del blocco nella griglia + int nIBlock = int( t) % int( m_nFracLin[0]) ; + int nJBlock = int( t) / int( m_nFracLin[0]) ; + + // Calcolo limiti per l'indice i + int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; + int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ? + int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; + + // Calcolo limiti per l'indice j + int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; + int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ? + int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; + + // Ciclo su i e j + for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) { + int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ; + for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) { + int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ; + GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, t) ; + } + } + + m_BlockToUpdate[t] = false ; + ++ m_BlockUpdatingCounter[t] ; + } + } + + return true ; } //---------------------------------------------------------------------------- @@ -780,10 +791,13 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin //---------------------------------------------------------------------------- bool -VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const +VolZmap::UpdateTripleMapGraphics( void) const { - nModifiedBlocks.resize( m_nNumBlock + 1, -1) ; - + // se non ci sono blocchi da aggiornare, esco + if ( find( begin( m_BlockToUpdate), end( m_BlockToUpdate), true) == end( m_BlockToUpdate)) + return true ; + + // contenitori temporanei vector vVoxContainerVec ; vVoxContainerVec.resize( m_nNumBlock) ; SharpTriaMatrix VecTriHold ; @@ -866,13 +880,10 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const } // Calcolo i triangoli sui blocchi - int nUpdatedBlockCount = 0 ; for ( int t = 0 ; t < m_nNumBlock ; ++ t) { // Se il blocco deve essere processato if ( m_BlockToUpdate[t]) { // processo ... - nModifiedBlocks[t] = nUpdatedBlockCount ; - ++ nUpdatedBlockCount ; ExtMarchingCubes( int( t), vVoxContainerVec[t]) ; } } @@ -882,15 +893,15 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const // Costruisco i triangoli di feature bool bCalcInterBlock = false ; - for ( int t = 0 ; t < int( m_nNumBlock) ; ++ t) { + for ( int t = 0 ; t < m_nNumBlock ; ++ t) { // Se il blocco è stato processato if ( m_BlockToUpdate[t]) { CreateSharpFeatureTriangle( t, vVoxContainerVec[t]) ; - ++ m_BlockUpdatingCounter[t] ; // Flipping fra voxel interni FlipEdgesII( t) ; bCalcInterBlock = true ; m_BlockToUpdate[t] = false ; + ++ m_BlockUpdatingCounter[t] ; // Sistemo le normali ai vertici (ciclo sui voxel) for ( int t1 = 0 ; t1 < int( m_BlockSharpTria[t].size()) ; ++ t1) { // ciclo sulle componenti connesse del voxel @@ -916,25 +927,23 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const SharpTriaMatrix InterBlockTria ; if ( bCalcInterBlock) { // Eseguo - m_InterBlockToBeFlippedSharpTria = m_InterBlockOriginalSharpTria ; - ++ m_BlockUpdatingCounter[m_nNumBlock] ; + m_InterBlockSharpTria = m_InterBlockOriginalSharpTria ; FlipEdgesBB() ; - // Aggiungo indice modificati - nModifiedBlocks.back() = nUpdatedBlockCount ; + ++ m_BlockUpdatingCounter[m_nNumBlock] ; // Sistemo le normali ai vertici - for ( int t = 0 ; t < int( m_InterBlockToBeFlippedSharpTria.size()) ; ++ t) { - for ( int t1 = 0 ; t1 < int( m_InterBlockToBeFlippedSharpTria[t].size()) ; ++ t1) { - for ( int t2 = 0 ; t2 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { - for ( int t3 = 0 ; t3 < int( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { - if ( m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { + for ( int t = 0 ; t < int( m_InterBlockSharpTria.size()) ; ++ t) { + for ( int t1 = 0 ; t1 < int( m_InterBlockSharpTria[t].size()) ; ++ t1) { + for ( int t2 = 0 ; t2 < int( m_InterBlockSharpTria[t][t1].vCompoTria.size()) ; ++ t2) { + for ( int t3 = 0 ; t3 < int( m_InterBlockSharpTria[t][t1].vCompoTria[t2].size()) ; ++ t3) { + if ( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) { // Controllo normali - Vector3d vtN = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetN() ; + Vector3d vtN = m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetN() ; bool bNormN = vtN.IsNormalized() ; for ( int nV = 0 ; nV < 3 ; ++ nV) { - Vector3d vtNV = m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; + Vector3d vtNV = m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetVertexNorm( nV) ; bool bNormV = vtNV.IsNormalized() ; if ( bNormN && bNormV && vtN * vtNV < 0.7) - m_InterBlockToBeFlippedSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; + m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].SetVertexNorm( nV, vtN) ; } } } @@ -946,60 +955,6 @@ VolZmap::UpdateTripleMapGraphics( INTVECTOR& nModifiedBlocks) const return true ; } -//---------------------------------------------------------------------------- -bool -VolZmap::UpdateSingleMapGraphics( INTVECTOR& nModifiedBlocks) const -{ - const int MAX_DIM_CHUNK = 128 ; - - int nUpdatedBlockCount = 0 ; - - // Ciclo sui blocchi - for ( int t = 0 ; t < m_nNumBlock ; ++ t) { - - // Se il blocco deve essere aggiornato, eseguo - if ( m_BlockToUpdate[t]) { - - m_SingleMapTria[t].clear() ; - - // Calcolo posizione del blocco nella griglia - int nIBlock = int( t) % int( m_nFracLin[0]) ; - int nJBlock = int( t) / int( m_nFracLin[0]) ; - - // Calcolo limiti per l'indice i - int nStartI = nIBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; - int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ? - int( m_nNx[0]) : ( nIBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; - - // Calcolo limiti per l'indice j - int nStartJ = nJBlock * int( m_nVoxNumPerBlock) * N_DEXVOXRATIO ; - int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ? - int( m_nNy[0]) : ( nJBlock + 1) * int( m_nVoxNumPerBlock)) * N_DEXVOXRATIO ; - - // Ciclo su i e j - for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) { - int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ; - for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) { - int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ; - GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, t) ; - } - } - - ++ m_BlockUpdatingCounter[t] ; - - nModifiedBlocks[t] = nUpdatedBlockCount ; - - ++ nUpdatedBlockCount ; - - m_BlockToUpdate[t] = false ; - } - else - nModifiedBlocks[t] = -1 ; - } - - return true ; -} - //---------------------------------------------------------------------------- bool VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const @@ -3177,7 +3132,7 @@ bool VolZmap::FlipEdgesBB() const { // Numero di blocchi - int nBlocksNum = int( m_InterBlockToBeFlippedSharpTria.size()) ; + int nBlocksNum = int( m_InterBlockSharpTria.size()) ; // ciclo sui blocchi for ( int tFB = 0 ; tFB < nBlocksNum ; ++ tFB) { int nFBijk[3] ; @@ -3191,45 +3146,45 @@ VolZmap::FlipEdgesBB() const abs( nFBijk[2] - nLBijk[2]) <= 1)) continue ; // Numero di voxel nei blocchi correnti - int nVoxelNumFB = int( m_InterBlockToBeFlippedSharpTria[tFB].size()) ; - int nVoxelNumLB = int( m_InterBlockToBeFlippedSharpTria[tLB].size()) ; + int nVoxelNumFB = int( m_InterBlockSharpTria[tFB].size()) ; + int nVoxelNumLB = int( m_InterBlockSharpTria[tLB].size()) ; // Ciclo sui voxel dei due blocchi for ( int tVFB = 0 ; tVFB < nVoxelNumFB ; ++ tVFB) { for ( int tVLB = 0 ; tVLB < nVoxelNumLB ; ++ tVLB) { // Se i voxel non sono adiacenti salto l'iterazione - if ( ! ( abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].i - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].i) <= 1 && - abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].j - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].j) <= 1 && - abs( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].k - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].k) <= 1)) + if ( ! ( abs( m_InterBlockSharpTria[tFB][tVFB].i - m_InterBlockSharpTria[tLB][tVLB].i) <= 1 && + abs( m_InterBlockSharpTria[tFB][tVFB].j - m_InterBlockSharpTria[tLB][tVLB].j) <= 1 && + abs( m_InterBlockSharpTria[tFB][tVFB].k - m_InterBlockSharpTria[tLB][tVLB].k) <= 1)) continue ; // Numero di componenti connesse dei voxel - int nCompoVFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert.size()) ; - int nCompoVLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert.size()) ; + int nCompoVFBNum = int( m_InterBlockSharpTria[tFB][tVFB].ptCompoVert.size()) ; + int nCompoVLBNum = int( m_InterBlockSharpTria[tLB][tVLB].ptCompoVert.size()) ; // Ciclo sulle componenti connesse for ( int tCmpF = 0 ; tCmpF < nCompoVFBNum ; ++ tCmpF) { for ( int tCmpL = 0 ; tCmpL < nCompoVLBNum ; ++ tCmpL) { // Numero di triangoli delle componenti connesse - int nTriFBNum = int( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF].size()) ; - int nTriLBNum = int( m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL].size()) ; + int nTriFBNum = int( m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF].size()) ; + int nTriLBNum = int( m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL].size()) ; // Ciclo sui triangoli for ( int tTriFB = 0 ; tTriFB < nTriFBNum ; ++ tTriFB) { bool bModified = false ; for ( int tTriLB = 0 ; tTriLB < nTriLBNum ; ++ tTriLB) { // Punti che devono essere in comune fra i due triangoli - Point3d ptPF1 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; - Point3d ptPF2 = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; - Point3d ptPL1 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ; - Point3d ptPL2 = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ; + Point3d ptPF1 = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; + Point3d ptPF2 = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; + Point3d ptPL1 = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 1) ; + Point3d ptPL2 = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetP( 2) ; // Si deve operare la modifica dei triangoli if ( AreSamePointEpsilon( ptPF1, ptPL2, EPS_ZERO) && AreSamePointEpsilon( ptPF2, ptPL1, EPS_ZERO) && - ! ( m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] || - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) { + ! ( m_InterBlockSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] || + m_InterBlockSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB])) { // Assegno l'array dei punti di contorno Point3d vPnt[4] ; - vPnt[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; - vPnt[1] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF] ; - vPnt[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; - vPnt[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL] ; + vPnt[0] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 1) ; + vPnt[1] = m_InterBlockSharpTria[tFB][tVFB].ptCompoVert[tCmpF] ; + vPnt[2] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetP( 2) ; + vPnt[3] = m_InterBlockSharpTria[tLB][tVLB].ptCompoVert[tCmpL] ; // Valuto se i triangoli giacciono su un piano PolygonPlane Polygon ; for ( int i = 0 ; i < 4 ; ++ i) @@ -3241,8 +3196,8 @@ VolZmap::FlipEdgesBB() const // Se sono su un piano controllo se avviene inversione bool bInv = false ; if ( bOnPlane) { - Triangle3dEx trTF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ; - Triangle3dEx trTL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ; + Triangle3dEx trTF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB] ; + Triangle3dEx trTL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB] ; int nVertF, nVertL ; // Determino gli indici dei punti sharp-feature for ( int nP = 0 ; nP < 3 ; ++ nP) { @@ -3260,26 +3215,26 @@ VolZmap::FlipEdgesBB() const // Se non vi è inversione eseguo il flipping if ( ! bInv) { // Vertice condiviso fra nTri1 e quello del suo fan - int nColF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; - int nColL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; + int nColF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; + int nColL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; // modifico punti e colori - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tLB][tVLB].ptCompoVert[tCmpL]) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, m_InterBlockToBeFlippedSharpTria[tFB][tVFB].ptCompoVert[tCmpF]) ; - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetP( 1, m_InterBlockSharpTria[tLB][tVLB].ptCompoVert[tCmpL]) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetP( 1, m_InterBlockSharpTria[tFB][tVFB].ptCompoVert[tCmpF]) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nColF) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nColL) ; // Valido i triangoli - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].Validate( true) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].Validate( true) ; // Setto le normali a ogni vertice - Vector3d vtNormF = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; - Vector3d vtNormL = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ; - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ; + Vector3d vtNormF = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; + Vector3d vtNormL = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 1, vtNormF) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetVertexNorm( 0, vtNormF) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 1, vtNormL) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetVertexNorm( 0, vtNormL) ; // Setto i triangoli come flippati - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ; + m_InterBlockSharpTria[tFB][tVFB].vbFlipped[tCmpF][tTriFB] = true ; + m_InterBlockSharpTria[tLB][tVLB].vbFlipped[tCmpL][tTriLB] = true ; bModified = true ; break ; } @@ -3288,14 +3243,14 @@ VolZmap::FlipEdgesBB() const // quindi hanno normali concordi. A entrambi assegno il colore del vertice con // normale più concorde a quella del triangolo double dDotVec[4] ; - dDotVec[0] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ; - dDotVec[1] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; - dDotVec[2] = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; - dDotVec[3] = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ; + dDotVec[0] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 1) ; + dDotVec[1] = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 2) ; + dDotVec[2] = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetN() * + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetVertexNorm( 2) ; + dDotVec[3] = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetN() * + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetVertexNorm( 1) ; // Cerco il massimo dei prodotti scalari int nMaxPos = 0 ; double dMaxDot = - 1 ; @@ -3309,21 +3264,21 @@ VolZmap::FlipEdgesBB() const int nCol ; switch ( nMaxPos) { case 0 : - nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ; + nCol = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 1) ; break ; case 1 : - nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; + nCol = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 2) ; break ; case 2 : - nCol = m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; + nCol = m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].GetAttrib( 2) ; break ; case 3 : - nCol = m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ; + nCol = m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].GetAttrib( 1) ; break ; } // Assegno il colore ai triangoli - m_InterBlockToBeFlippedSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ; - m_InterBlockToBeFlippedSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ; + m_InterBlockSharpTria[tFB][tVFB].vCompoTria[tCmpF][tTriFB].SetGrade( nCol) ; + m_InterBlockSharpTria[tLB][tVLB].vCompoTria[tCmpL][tTriLB].SetGrade( nCol) ; } } }