diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 864a5d8..ba4f433 100644 Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ diff --git a/VolTriZmapCalculus.cpp b/VolTriZmapCalculus.cpp index cabd1c6..3c25fff 100644 --- a/VolTriZmapCalculus.cpp +++ b/VolTriZmapCalculus.cpp @@ -18,7 +18,7 @@ #include "VolZmap.h" #include "GeoConst.h" #include "IntersLineSurfTm.h" -#include "\EgtDev\Include\EgtNumUtils.h" +#include "/EgtDev/Include/EgtNumUtils.h" using namespace std ; @@ -288,10 +288,10 @@ VolZmap::IntersLineDexel( unsigned int nGrid, const Point3d& ptP, const Vector3d dU1 = INFINITO ; dU2 = - INFINITO ; bool bInters = false ; - for ( unsigned int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 2) { + for ( unsigned int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 1) { // estremi del box del singolo intervallo - Point3d ptE1( dXmin, dYmin, m_Values[nGrid][nDexelPos][nIndex].dZVal) ; - Point3d ptE2( dXmax, dYmax, m_Values[nGrid][nDexelPos][nIndex+1].dZVal) ; + Point3d ptE1( dXmin, dYmin, m_Values[nGrid][nDexelPos][nIndex].dMin) ; + Point3d ptE2( dXmax, dYmax, m_Values[nGrid][nDexelPos][nIndex].dMax) ; double dt1, dt2 ; if ( IntersLineBox( ptP, vtV, ptE1, ptE2, dt1, dt2)) { bInters = true ; @@ -478,9 +478,9 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag) double dZmin, dZmax ; if ( IntersLineBox( ptC, vtK, ORIG, ORIG + vtDiag, dZmin, dZmax)) { - for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 2) { - if ( ! ( dZmax < m_Values[0][nPos][nIndex].dZVal - EPS_SMALL || - dZmin > m_Values[0][nPos][nIndex + 1].dZVal + EPS_SMALL)) + for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) { + if ( ! ( dZmax < m_Values[0][nPos][nIndex].dMin - EPS_SMALL || + dZmin > m_Values[0][nPos][nIndex + 1].dMax + EPS_SMALL)) return false ; } } diff --git a/VolTriZmapCreation.cpp b/VolTriZmapCreation.cpp index 0a63b04..e6c113e 100644 --- a/VolTriZmapCreation.cpp +++ b/VolTriZmapCreation.cpp @@ -18,7 +18,7 @@ #include "VolZmap.h" #include "GeoConst.h" #include "IntersLineSurfTm.h" -#include "\EgtDev\Include\EgtNumUtils.h" +#include "/EgtDev/Include/EgtNumUtils.h" using namespace std ; @@ -29,8 +29,7 @@ using namespace std ; bool VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dPrec, bool bFlag) { - - // Controlli l'ammissibilità delle dimensioni lineari del grezzo e del passo + // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo if ( dPrec < EPS_SMALL || dLengthX < EPS_SMALL || dLengthY < EPS_SMALL || dLengthZ < EPS_SMALL) return false ; @@ -61,6 +60,10 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_nNy[0] / m_nDexNumPBlock + ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + // Numero di componenti connesse + m_nConnectedCompoCount = 1 ; + + // Se tridexel if ( bFlag) { m_MapFrame[1].Set( ptO, Y_AX, Z_AX, X_AX) ; @@ -77,6 +80,7 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL m_nNy[1] / m_nDexNumPBlock + ( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; } + // altrimenti mono dexel else { m_MapFrame[1].Set( ptO, Y_AX, Z_AX, X_AX) ; @@ -97,61 +101,61 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL // Creazione delle mappe // Calcolo del numero di celle per ogni mappa for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) - m_nDim[i] = m_nNx[i] * m_nNy[i] ; // Creazione delle celle per ogni mappa for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) - m_Values[i].resize( m_nDim[i]) ; // Riempimento delle celle for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { - m_Values[i][j].resize(2) ; + // Aggiungo il tratto al dexel vuoto + m_Values[i][j].resize( 1) ; - m_Values[i][j][0].dZVal = 0 ; + m_Values[i][j][0].dMin = 0 ; + m_Values[i][j][0].nToolMin = 0 ; + + m_Values[i][j][0].nCompo = 1 ; switch ( i) { case 0 : - m_Values[i][j][1].dZVal = dLengthZ ; - m_Values[i][j][0].vtN = Vector3d( 0, 0, - 1) ; - m_Values[i][j][1].vtN = Vector3d( 0, 0, 1) ; + m_Values[i][j][0].vtMinN = - Z_AX ; + m_Values[i][j][0].dMax = dLengthZ ; + m_Values[i][j][0].vtMaxN = Z_AX ; + m_Values[i][j][0].nToolMax = 0 ; break ; case 1 : - m_Values[i][j][1].dZVal = dLengthX ; - m_Values[i][j][0].vtN = Vector3d( - 1, 0, 0) ; - m_Values[i][j][1].vtN = Vector3d( 1, 0, 0) ; + m_Values[i][j][0].vtMinN = - X_AX ; + m_Values[i][j][0].dMax = dLengthX ; + m_Values[i][j][0].vtMaxN = X_AX ; + m_Values[i][j][0].nToolMax = 0 ; break ; case 2 : - m_Values[i][j][1].dZVal = dLengthY ; - m_Values[i][j][0].vtN = Vector3d( 0, - 1, 0) ; - m_Values[i][j][1].vtN = Vector3d( 0, 1, 0) ; + m_Values[i][j][0].vtMinN = - Y_AX ; + m_Values[i][j][0].dMax = dLengthY ; + m_Values[i][j][0].vtMaxN = Y_AX ; + m_Values[i][j][0].nToolMax = 0 ; break ; } } // Definizione delle limitazioni iniziali in Z per ogni mappa for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { - m_dMinZ[i] = 0 ; - - if ( i == 0) - m_dMaxZ[i] = dLengthZ ; - else if ( i == 1) - m_dMaxZ[i] = dLengthX ; - else if ( i == 2) - m_dMaxZ[i] = dLengthY ; + switch ( i) { + case 0 : m_dMaxZ[i] = dLengthZ ; break ; + case 1 : m_dMaxZ[i] = dLengthX ; break ; + case 2 : m_dMaxZ[i] = dLengthY ; break ; + } } // Ridimensiono e setto il vettore dei blocchi a falso - m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; + m_nNumBlock = ( bFlag ? m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] : m_nFracLin[0] * m_nFracLin[1]) ; m_BlockToUpdate.resize( m_nNumBlock) ; - for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) - m_BlockToUpdate[nCount] = true ; m_InterBlockTria.resize( m_nNumBlock) ; @@ -166,8 +170,6 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL bool VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bFlag) { - Point3d ptMapOrig, ptMapEnd ; - // Aggiorno la dimensione della mappa 1 o 3 m_nMapNum = ( bFlag ? 3 : 1) ; @@ -179,6 +181,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double Surf.GetLocalBBox( SurfBBox, BBF_EXACT) ; // Determino i punti estremi del bounding box + Point3d ptMapOrig, ptMapEnd ; SurfBBox.GetMinMax( ptMapOrig, ptMapEnd) ; // Sistema di riferimento mappa @@ -208,6 +211,9 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double m_nNy[0] / m_nDexNumPBlock + ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + // Numero di componenti connesse + m_nConnectedCompoCount = - 1 ; + // Se Tridexel ridimensiono anche gli altri vettori if ( bFlag) { @@ -278,24 +284,29 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double // Se la retta è interna alla regione o coincidente con parte della sua frontiera if ( nType == CRVC_IN || nType == CRVC_ON_P || nType == CRVC_ON_M) { - + // Indici corrispondenti alle coordinate dei punti int nStartJ = Clamp( int( floor( dt1 * dLengthY / m_dStep - EPS_SMALL + 0.5)), 0, m_nNy[0] - 1) ; - int nEndJ = Clamp( int( floor( dt2 * dLengthY / m_dStep + EPS_SMALL - 0.5)), 0, m_nNy[0] - 1) ; + int nEndJ = Clamp( int( floor( dt2 * dLengthY / m_dStep + EPS_SMALL - 0.5)), 0, m_nNy[0] - 1) ; // Ridimensiono e riempio i dexel for ( int j = nStartJ ; j <= nEndJ ; ++ j) { // Determino il dexel int nPos0 = j * m_nNx[0] + i ; - m_Values[0][nPos0].resize( 2) ; - // Aggiorno le quote estreme del segmento - m_Values[0][nPos0][0].dZVal = 0 ; - m_Values[0][nPos0][1].dZVal = dDimZ ; - m_Values[0][nPos0][0].vtN = - Z_AX ; - m_Values[0][nPos0][1].vtN = Z_AX ; + // Aggiungo il tratto al dexel vuoto + m_Values[0][nPos0].resize( 1) ; + + // Aggiorno i dati del tratto di dexel + m_Values[0][nPos0][0].dMin = 0 ; + m_Values[0][nPos0][0].dMax = dDimZ ; + m_Values[0][nPos0][0].nToolMin = 0 ; + m_Values[0][nPos0][0].vtMinN = - Z_AX ; + m_Values[0][nPos0][0].vtMaxN = Z_AX ; + m_Values[0][nPos0][0].nToolMax = 0 ; + m_Values[0][nPos0][0].nCompo = 0 ; } - + // Se tridexel riempio i singoli dexel della // griglia 2 con gli intervalli if ( bFlag) { @@ -306,10 +317,14 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double size_t nCurrentSize = m_Values[2][nPos2].size( ) ; - m_Values[2][nPos2].resize( nCurrentSize + 2) ; + // Aggiungo un tratto al dexel + m_Values[2][nPos2].resize( nCurrentSize + 1) ; - m_Values[2][nPos2][nCurrentSize].dZVal = dt1 * dLengthY ; - m_Values[2][nPos2][nCurrentSize + 1].dZVal = dt2 * dLengthY ; + // Aggiorno quote e numero di utensile al tratto di dexel + m_Values[2][nPos2][nCurrentSize].dMin = dt1 * dLengthY ; + m_Values[2][nPos2][nCurrentSize].nToolMin = 0 ; + m_Values[2][nPos2][nCurrentSize].dMax = dt2 * dLengthY ; + m_Values[2][nPos2][nCurrentSize].nToolMax = 0 ; Point3d ptP1 = ptP0 + dt1 * dLengthY * Y_AX ;//+ ( a + 0.5) * Z_AX ; Point3d ptP2 = ptP0 + dt2 * dLengthY * Y_AX ;//+ ( a + 0.5) * Z_AX ; @@ -334,7 +349,8 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double vtN1 = vtT1 ^ Z_AX ; - m_Values[2][nPos2][nCurrentSize].vtN = vtN1 ; + // Aggiorno normale inferiore al tratto di dexel + m_Values[2][nPos2][nCurrentSize].vtMinN = vtN1 ; } @@ -348,12 +364,18 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double vtN2 = vtT2 ^ Z_AX ; - m_Values[2][nPos2][nCurrentSize+1].vtN = vtN2 ; + // Aggiorno normale superiore al tratto di dexel + m_Values[2][nPos2][nCurrentSize].vtMaxN = vtN2 ; } } - } + } + + // Aggiorno il numero della componente connessa + m_Values[2][nPos2][nCurrentSize].nCompo = 0 ; } } + + } } } @@ -394,10 +416,16 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double size_t nCurrentSize = m_Values[1][nPos1].size( ) ; - m_Values[1][nPos1].resize( nCurrentSize + 2) ; + // Aggiungo un tratto al dexel + m_Values[1][nPos1].resize( nCurrentSize + 1) ; - m_Values[1][nPos1][nCurrentSize].dZVal = dt1 * dLengthX ; - m_Values[1][nPos1][nCurrentSize + 1].dZVal = dt2 * dLengthX ; + // Aggiorno quote e numero di utensile al tratto di dexel + m_Values[1][nPos1][nCurrentSize].dMin = dt1 * dLengthX ; + m_Values[1][nPos1][nCurrentSize].nToolMin = 0 ; + m_Values[1][nPos1][nCurrentSize].dMax = dt2 * dLengthX ; + m_Values[1][nPos1][nCurrentSize].nToolMax = 0 ; + // Aggiorno il numero della componente connessa + m_Values[1][nPos1][nCurrentSize].nCompo = 0 ; Point3d ptP1 = ptP0 + dt1 * dLengthX * X_AX ; Point3d ptP2 = ptP0 + dt2 * dLengthX * X_AX ; @@ -421,8 +449,8 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double pCurve -> GetPointTang( dP1, ICurve::FROM_MINUS, ptP1, vtT1) ; vtN1 = vtT1 ^ Z_AX ; - - m_Values[1][nPos1][nCurrentSize].vtN = vtN1 ; + // Aggiorno normale inferiore al tratto di dexel + m_Values[1][nPos1][nCurrentSize].vtMinN = vtN1 ; } @@ -435,8 +463,8 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double pCurve -> GetPointTang( dP2, ICurve::FROM_MINUS, ptP1, vtT2) ; vtN2 = vtT2 ^ Z_AX ; - - m_Values[1][nPos1][nCurrentSize+1].vtN = vtN2 ; + // Aggiorno normale superiore al tratto di dexel + m_Values[1][nPos1][nCurrentSize].vtMaxN = vtN2 ; } } } @@ -446,7 +474,6 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double } } - m_dMinZ[0] = 0 ; m_dMaxZ[0] = dDimZ ; @@ -466,12 +493,10 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double } // Ridimensiono e setto il vettore dei blocchi a falso - m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; + m_nNumBlock = ( bFlag ? m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] : m_nFracLin[0] * m_nFracLin[1]) ; m_BlockToUpdate.resize( m_nNumBlock) ; - for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) - m_BlockToUpdate[nCount] = true ; m_InterBlockTria.resize( m_nNumBlock) ; @@ -533,6 +558,9 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) m_nNy[0] / m_nDexNumPBlock + ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ; + // Numero di componenti connesse + m_nConnectedCompoCount = - 1 ; + // Se Tridexel ridimensiono anche gli altri vettori if ( bFlag) { @@ -618,14 +646,19 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) Surf.GetFacetNormal( nF, vtOutN) ; unsigned int nCurrentSize = unsigned int( m_Values[0][nPos].size()) ; - - m_Values[0][nPos].resize( nCurrentSize + 2) ; + + // Aggiungo un tratto al dexel + m_Values[0][nPos].resize( nCurrentSize + 1) ; - m_Values[0][nPos][nCurrentSize].dZVal = ptIn.z - ptMapOrig.z ; - m_Values[0][nPos][nCurrentSize + 1].dZVal = ptOut.z - ptMapOrig.z ; - - m_Values[0][nPos][nCurrentSize].vtN = vtInN ; - m_Values[0][nPos][nCurrentSize + 1].vtN = vtOutN ; + // Aggiorno dati del tratto di dexel + m_Values[0][nPos][nCurrentSize].dMin = ptIn.z - ptMapOrig.z ; + m_Values[0][nPos][nCurrentSize].dMax = ptOut.z - ptMapOrig.z ; + m_Values[0][nPos][nCurrentSize].vtMinN = vtInN ; + m_Values[0][nPos][nCurrentSize].vtMaxN = vtOutN ; + m_Values[0][nPos][nCurrentSize].nToolMin = 0 ; + m_Values[0][nPos][nCurrentSize].nToolMax = 0 ; + m_Values[0][nPos][nCurrentSize].nCompo = 0 ; + bInside = false ; } @@ -694,14 +727,18 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) Surf.GetFacetNormal( nF, vtOutN) ; unsigned int nCurrentSize = unsigned int( m_Values[1][nPos].size()) ; - - m_Values[1][nPos].resize( nCurrentSize + 2) ; + + // Aggiungo un tratto al dexel + m_Values[1][nPos].resize( nCurrentSize + 1) ; - m_Values[1][nPos][nCurrentSize].dZVal = ptIn.x - ptMapOrig.x ; - m_Values[1][nPos][nCurrentSize + 1].dZVal = ptOut.x - ptMapOrig.x ; - - m_Values[1][nPos][nCurrentSize].vtN = vtInN ; - m_Values[1][nPos][nCurrentSize + 1].vtN = vtOutN ; + // Aggiorno dati del tratto di dexel + m_Values[1][nPos][nCurrentSize].dMin = ptIn.x - ptMapOrig.x ; + m_Values[1][nPos][nCurrentSize].dMax = ptOut.x - ptMapOrig.x ; + m_Values[1][nPos][nCurrentSize].vtMinN = vtInN ; + m_Values[1][nPos][nCurrentSize].vtMaxN = vtOutN ; + m_Values[1][nPos][nCurrentSize].nToolMin = 0 ; + m_Values[1][nPos][nCurrentSize].nToolMax = 0 ; + m_Values[1][nPos][nCurrentSize].nCompo = 0 ; bInside = false ; } @@ -768,14 +805,18 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) Surf.GetFacetNormal( nF, vtOutN) ; unsigned int nCurrentSize = unsigned int( m_Values[2][nPos].size()) ; - - m_Values[2][nPos].resize( nCurrentSize + 2) ; + + // Aggiungo un tratto al dexel + m_Values[2][nPos].resize( nCurrentSize + 1) ; - m_Values[2][nPos][nCurrentSize].dZVal = ptIn.y - ptMapOrig.y ; - m_Values[2][nPos][nCurrentSize + 1].dZVal = ptOut.y - ptMapOrig.y ; - - m_Values[2][nPos][nCurrentSize].vtN = vtInN ; - m_Values[2][nPos][nCurrentSize + 1].vtN = vtOutN ; + // Aggiorno dati del tratto di dexel + m_Values[2][nPos][nCurrentSize].dMin = ptIn.y - ptMapOrig.y ; + m_Values[2][nPos][nCurrentSize].dMax = ptOut.y - ptMapOrig.y ; + m_Values[2][nPos][nCurrentSize].vtMinN = vtInN ; + m_Values[2][nPos][nCurrentSize].vtMaxN = vtOutN ; + m_Values[2][nPos][nCurrentSize].nToolMin = 0 ; + m_Values[2][nPos][nCurrentSize].nToolMax = 0 ; + m_Values[2][nPos][nCurrentSize].nCompo = 0 ; bInside = false ; } @@ -790,14 +831,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) m_dMaxZ[0] = dLengthZ ; if ( bFlag) { - m_dMinZ[1] = 0 ; m_dMaxZ[1] = dLengthX ; m_dMinZ[2] = 0 ; m_dMaxZ[2] = dLengthY ; } else { - m_dMinZ[1] = 0 ; m_dMaxZ[1] = 0 ; m_dMinZ[2] = 0 ; @@ -805,12 +844,10 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag) } // Ridimensiono e setto il vettore dei blocchi a falso - m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ; + m_nNumBlock = ( bFlag ? m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] : m_nFracLin[0] * m_nFracLin[1]) ; m_BlockToUpdate.resize( m_nNumBlock) ; - for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) - m_BlockToUpdate[nCount] = true ; m_InterBlockTria.resize( m_nNumBlock) ; diff --git a/VolTriZmapGraphics.cpp b/VolTriZmapGraphics.cpp index 8181bb2..6621fb1 100644 --- a/VolTriZmapGraphics.cpp +++ b/VolTriZmapGraphics.cpp @@ -19,27 +19,23 @@ #include "GeoConst.h" #include "IntersLineSurfTm.h" #include "MC_Tables.h" -#include "\EgtDev\Include\EGkIntervals.h" -#include "\EgtDev\Include\EgtNumUtils.h" -#include "\EgtDev\Include\EGkStringUtils3d.h" -#include "\EgtDev\Extern\Eigen\Core" -#include "\EgtDev\Extern\Eigen\SVD" +#include "/EgtDev/Include/EGkIntervals.h" +#include "/EgtDev/Include/EgtNumUtils.h" +#include "/EgtDev/Include/EGkStringUtils3d.h" +#include "/EgtDev/Extern/Eigen\Core" +#include "/EgtDev/Extern/Eigen\SVD" using namespace std ; // ------------------------- STRUTTURA VERTICE TRIANGOLO - NORMALE ALLA SUPERFICIE ------------------------------------------------ - struct VectorField { - Point3d ptInt ; Vector3d vtNorm ; } ; // ------------------------- TABELLA BLOCCHI ADIACENTI ---------------------------------------------------------------------------- - static int NeighbourTable[8][4] = { - {0, -1, -1, -1}, {1, 1, -1, -1}, {1, 1, 2, -1}, @@ -51,7 +47,6 @@ static int NeighbourTable[8][4] = { } ; // ------------------------- FUNZIONE TEST SULLE NORMALI -------------------------------------------------------------------------- - enum FatureType { NoFeature = 0, Corner = 1, Edge = 2} ; //---------------------------------------------------------------------------- @@ -146,12 +141,12 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con Point3d ptP = m_MapFrame[nDir].Orig() + dX * m_MapFrame[nDir].VersX() + dY * m_MapFrame[nDir].VersY() ; // Creo le polilinee - for ( int j = 1 ; j < int( m_Values[nDir][nPos].size()) ; j += 2) { + for ( int j = 0 ; j < int( m_Values[nDir][nPos].size()) ; j += 1) { // aggiungo polilinea a lista lstPL.emplace_back() ; // inserisco punti estremi - lstPL.back().AddUPoint( 0, ptP + m_Values[nDir][nPos][j-1].dZVal * m_MapFrame[nDir].VersZ()) ; - lstPL.back().AddUPoint( 1, ptP + m_Values[nDir][nPos][j].dZVal * m_MapFrame[nDir].VersZ()) ; + lstPL.back().AddUPoint( 0, ptP + m_Values[nDir][nPos][j].dMin * m_MapFrame[nDir].VersZ()) ; + lstPL.back().AddUPoint( 1, ptP + m_Values[nDir][nPos][j].dMax * m_MapFrame[nDir].VersZ()) ; } return true ; } @@ -182,23 +177,23 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con Point3d ptP = m_MapFrame[nDir].Orig() + dX * m_MapFrame[nDir].VersX() + dY * m_MapFrame[nDir].VersY() ; // Creo le polilinee - for ( int j = 1 ; j < int( m_Values[nDir][nPos].size()) ; j += 2) { + for ( int j = 0 ; j < int( m_Values[nDir][nPos].size()) ; j += 1) { // aggiungo polilinea a lista lstPL.emplace_back() ; // calcolo e inserisco punto inizio spillone - Point3d ptQ = ptP + m_Values[nDir][nPos][j-1].dZVal * m_MapFrame[nDir].VersZ() ; + Point3d ptQ = ptP + m_Values[nDir][nPos][j].dMin * m_MapFrame[nDir].VersZ() ; lstPL.back().AddUPoint( 0, ptQ) ; // calcolo e inserisco punto su termine sua normale - Vector3d vtV = m_Values[nDir][nPos][j-1].vtN ; + Vector3d vtV = m_Values[nDir][nPos][j].vtMinN ; vtV.ToGlob( m_MapFrame[0]) ; lstPL.back().AddUPoint( 1, ptQ + vtV * m_dStep / 4) ; // aggiungo polilinea a lista lstPL.emplace_back() ; // calcolo e inserisco punto fine spillone - Point3d ptR = ptP + m_Values[nDir][nPos][j].dZVal * m_MapFrame[nDir].VersZ() ; + Point3d ptR = ptP + m_Values[nDir][nPos][j].dMax * m_MapFrame[nDir].VersZ() ; lstPL.back().AddUPoint( 0, ptR) ; // calcolo e inserisco punto su termine sua normale - Vector3d vtW = m_Values[nDir][nPos][j].vtN ; + Vector3d vtW = m_Values[nDir][nPos][j].vtMaxN ; vtW.ToGlob( m_MapFrame[0]) ; lstPL.back().AddUPoint( 1, ptR + vtW * m_dStep / 4) ; } @@ -371,7 +366,7 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DLISTVE int VolZmap::GetBlockCount( void) const { - return m_nNumBlock + 1 ; + return m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1) ; } //---------------------------------------------------------------------------- @@ -386,14 +381,14 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk for ( int j = 0 ; j < nDim2 && bIsSimple ; ++ j) { int nPos = ( nPos1 + i) + ( nPos2 + j) * m_nNx[0] ; if ( nPos > int( m_nDim[0]) || - int( m_Values[0][nPos].size()) != 2) + int( m_Values[0][nPos].size()) != 1) bIsSimple = false ; else if ( i == 0 && j == 0) { - dBotZ = m_Values[0][nPos][0].dZVal ; - dTopZ = m_Values[0][nPos][1].dZVal ; + dBotZ = m_Values[0][nPos][0].dMin ; + dTopZ = m_Values[0][nPos][0].dMax ; } - else if ( abs( m_Values[0][nPos][0].dZVal - dBotZ) > EPS_SMALL || - abs( m_Values[0][nPos][1].dZVal - dTopZ) > EPS_SMALL) + else if ( abs( m_Values[0][nPos][0].dMin - dBotZ) > EPS_SMALL || + abs( m_Values[0][nPos][0].dMax - dTopZ) > EPS_SMALL) bIsSimple = false ; } } @@ -445,8 +440,8 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST Point3d ptP4 = ptP1 + nDim2 * m_dStep * m_MapFrame[0].VersY() ; // creo le facce sopra e sotto - Vector3d vtDZt = m_Values[0][nPos][1].dZVal * m_MapFrame[0].VersZ() ; - Vector3d vtDZb = m_Values[0][nPos][0].dZVal * m_MapFrame[0].VersZ() ; + Vector3d vtDZt = m_Values[0][nPos][0].dMax * m_MapFrame[0].VersZ() ; + Vector3d vtDZb = m_Values[0][nPos][0].dMin * m_MapFrame[0].VersZ() ; // faccia superiore P1t->P2t->P3t->P4t : sempre visibile lstTria.emplace_back() ; lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame[0].VersZ()) ; @@ -487,7 +482,7 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST Point3d ptP2D = ptP1D + m_dStep * m_MapFrame[0].VersX() ; AddDexelSideFace( nPosD, nPosSud, ptP1D, ptP2D, m_MapFrame[0].VersZ(), - m_MapFrame[0].VersY(), lstTria) ; } - +// return true ; } @@ -511,9 +506,9 @@ VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const Point3d ptP4 = ptP1 + m_dStep * m_MapFrame[0].VersY() ; // creo le facce sopra e sotto di ogni intervallo (sempre visibili) - for ( int i = 1 ; i < int( m_Values[0][nPos].size()) ; i += 2) { - Vector3d vtDZt = m_Values[0][nPos][i].dZVal * m_MapFrame[0].VersZ() ; - Vector3d vtDZb = m_Values[0][nPos][i-1].dZVal * m_MapFrame[0].VersZ() ; + for ( int i = 0 ; i < int( m_Values[0][nPos].size()) ; i += 1) { + Vector3d vtDZt = m_Values[0][nPos][i].dMax * m_MapFrame[0].VersZ() ; + Vector3d vtDZb = m_Values[0][nPos][i].dMin * m_MapFrame[0].VersZ() ; // faccia superiore P1t->P2t->P3t->P4t : sempre visibile lstTria.emplace_back() ; lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame[0].VersZ()) ; @@ -545,11 +540,11 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DLIST& lstTria) const { Intervals intFace ; - for ( int i = 1 ; i < int( m_Values[0][nPos].size()) ; i += 2) - intFace.Add( m_Values[0][nPos][i-1].dZVal, m_Values[0][nPos][i].dZVal) ; + for ( int i = 0 ; i < int( m_Values[0][nPos].size()) ; i += 1) + intFace.Add( m_Values[0][nPos][i].dMin, m_Values[0][nPos][i].dMax) ; if ( nPosAdj > 0) { - for ( int i = 1 ; i < int( m_Values[0][nPosAdj].size()) ; i += 2) - intFace.Subtract( m_Values[0][nPosAdj][i-1].dZVal, m_Values[0][nPosAdj][i].dZVal) ; + for ( int i = 0 ; i < int( m_Values[0][nPosAdj].size()) ; i += 1) + intFace.Subtract( m_Values[0][nPosAdj][i].dMin, m_Values[0][nPosAdj][i].dMax) ; } double dMin, dMax ; bool bFound = intFace.GetFirst( dMin, dMax) ; @@ -787,6 +782,8 @@ VolZmap::ExtMarchingCubes( const int nLimits[], size_t nBlockNumber, TRIA3DLIST& for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) { for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) { + /*if ( !( i == 2 && j == 14 && k == 24)) + continue ;*/ // Riconoscimento dei voxel di frontiera bool bBoundary = false ; int nVoxIndexes[3] = { i, j, k} ; @@ -1971,13 +1968,13 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const while ( nIndex < nDexSize) { - if ( dZ[nGrid] > m_Values[nGrid][nPos][nIndex].dZVal - dEps && - dZ[nGrid] < m_Values[nGrid][nPos][nIndex + 1].dZVal + dEps) { + if ( dZ[nGrid] > m_Values[nGrid][nPos][nIndex].dMin - dEps && + dZ[nGrid] < m_Values[nGrid][nPos][nIndex].dMax + dEps) { ++ nCount ; break ; } - nIndex += 2 ; + nIndex += 1 ; } } return ( nCount == 3) ; @@ -2002,10 +1999,10 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt) const size_t nSize = m_Values[1][nDexel].size() ; bool bFound = false ; - for ( size_t i = 0 ; i < nSize ; i += 2) { + for ( size_t i = 0 ; i < nSize ; i += 1) { - double dx1 = m_Values[1][nDexel][i].dZVal ; - double dx2 = m_Values[1][nDexel][i+1].dZVal ; + double dx1 = m_Values[1][nDexel][i].dMin ; + double dx2 = m_Values[1][nDexel][i].dMax ; if ( dx1 < dMinX - EPS_SMALL && dx2 > dMinX - EPS_SMALL && dx2 < dMaxX + EPS_SMALL) { ptInt.x = dx2 ; @@ -2037,10 +2034,10 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt) const size_t nSize = m_Values[2][nDexel].size() ; bool bFound = false ; - for ( size_t j = 0 ; j < nSize ; j += 2) { + for ( size_t j = 0 ; j < nSize ; j += 1) { - double dy1 = m_Values[2][nDexel][j].dZVal ; - double dy2 = m_Values[2][nDexel][j+1].dZVal ; + double dy1 = m_Values[2][nDexel][j].dMin ; + double dy2 = m_Values[2][nDexel][j].dMax ; if ( dy1 < dMinY - EPS_SMALL && dy2 > dMinY - EPS_SMALL && dy2 < dMaxY + EPS_SMALL) { ptInt.y = dy2 ; @@ -2072,10 +2069,10 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt) const size_t nSize = m_Values[0][nDexel].size() ; bool bFound = false ; - for ( size_t k = 0 ; k < nSize ; k += 2) { + for ( size_t k = 0 ; k < nSize ; k += 1) { - double dz1 = m_Values[0][nDexel][k].dZVal ; - double dz2 = m_Values[0][nDexel][k+1].dZVal ; + double dz1 = m_Values[0][nDexel][k].dMin ; + double dz2 = m_Values[0][nDexel][k].dMax ; if ( dz1 < dMinZ - EPS_SMALL && dz2 > dMinZ - EPS_SMALL && dz2 < dMaxZ + EPS_SMALL) { ptInt.z = dz2 ; @@ -2119,46 +2116,44 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, if ( bFirstCorner) { - size_t n = nSize - 1 ; - double dX = m_Values[1][nDexel][n].dZVal ; + int n = int( nSize) - 1 ; + double dX = m_Values[1][nDexel][n].dMax ; - while ( n > 0 && dX > dMinX - dEps) { + while ( n >= 0 && dX > dMinX - dEps) { if ( dX < dMaxX + dEps) { ptInt.x = dX ; - vtNormal = m_Values[1][nDexel][n].vtN ; + vtNormal = m_Values[1][nDexel][n].vtMaxN ; bFound = true ; break ; } - - if ( n == 1) - break ; + + n -= 1 ; - n -= 2 ; - dX = m_Values[1][nDexel][n].dZVal ; + if ( n >= 0) + dX = m_Values[1][nDexel][n].dMax ; } } else { size_t n = 0 ; - double dX = m_Values[1][nDexel][0].dZVal ; + double dX = m_Values[1][nDexel][n].dMin ; - while ( n <= nSize - 2 && dX < dMaxX + dEps) { + while ( n < nSize && dX < dMaxX + dEps) { if ( dX > dMinX - dEps) { ptInt.x = dX ; - vtNormal = m_Values[1][nDexel][n].vtN ; + vtNormal = m_Values[1][nDexel][n].vtMinN ; bFound = true ; break ; } - - if ( n == nSize - 2) - break ; + + n += 1 ; - n += 2 ; - dX = m_Values[1][nDexel][n].dZVal ; + if ( n < nSize) + dX = m_Values[1][nDexel][n].dMin ; } } @@ -2183,46 +2178,44 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, if ( bFirstCorner) { - size_t n = nSize - 1 ; - double dY = m_Values[2][nDexel][n].dZVal ; + int n = int( nSize) - 1 ; + double dY = m_Values[2][nDexel][n].dMax ; - while ( n > 0 && dY > dMinY - dEps) { + while ( n >= 0 && dY > dMinY - dEps) { if ( dY < dMaxY + dEps) { ptInt.y = dY ; - vtNormal = m_Values[2][nDexel][n].vtN ; + vtNormal = m_Values[2][nDexel][n].vtMaxN ; bFound = true ; break ; } - - if ( n == 1) - break ; + + n -= 1 ; - n -= 2 ; - dY = m_Values[2][nDexel][n].dZVal ; + if ( n >= 0) + dY = m_Values[2][nDexel][n].dMax ; } } else { size_t n = 0 ; - double dY = m_Values[2][nDexel][0].dZVal ; + double dY = m_Values[2][nDexel][n].dMin ; - while ( n <= nSize - 2 && dY < dMaxY + dEps) { + while ( n < nSize && dY < dMaxY + dEps) { if ( dY > dMinY - dEps) { ptInt.y = dY ; - vtNormal = m_Values[2][nDexel][n].vtN ; + vtNormal = m_Values[2][nDexel][n].vtMinN ; bFound = true ; break ; } - - if ( n == nSize - 2) - break ; + + n += 1 ; - n += 2 ; - dY = m_Values[2][nDexel][n].dZVal ; + if ( n < nSize) + dY = m_Values[2][nDexel][n].dMin ; } } @@ -2247,46 +2240,44 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, Point3d& ptInt, if ( bFirstCorner) { - size_t n = nSize - 1 ; - double dZ = m_Values[0][nDexel][n].dZVal ; + int n = int( nSize) - 1 ; + double dZ = m_Values[0][nDexel][n].dMax ; - while ( n > 0 && dZ > dMinZ - dEps) { + while ( n >= 0 && dZ > dMinZ - dEps) { if ( dZ < dMaxZ + dEps) { ptInt.z = dZ ; - vtNormal = m_Values[0][nDexel][n].vtN ; + vtNormal = m_Values[0][nDexel][n].vtMaxN ; bFound = true ; break ; } - - if ( n == 1) - break ; + + n -= 1 ; - n -= 2 ; - dZ = m_Values[0][nDexel][n].dZVal ; + if ( n >= 0) + dZ = m_Values[0][nDexel][n].dMax ; } } else { size_t n = 0 ; - double dZ = m_Values[0][nDexel][0].dZVal ; + double dZ = m_Values[0][nDexel][n].dMin ; - while ( n <= nSize - 2 && dZ < dMaxZ + dEps) { + while ( n < nSize && dZ < dMaxZ + dEps) { if ( dZ > dMinZ - dEps) { ptInt.z = dZ ; - vtNormal = m_Values[0][nDexel][n].vtN ; + vtNormal = m_Values[0][nDexel][n].vtMinN ; bFound = true ; break ; } - - if ( n == nSize - 2) - break ; + + n += 1 ; - n += 2 ; - dZ = m_Values[0][nDexel][n].dZVal ; + if ( n < nSize) + dZ = m_Values[0][nDexel][n].dMin ; } } diff --git a/VolTriZmapVolume.cpp b/VolTriZmapVolume.cpp index 7e29999..6ee9574 100644 --- a/VolTriZmapVolume.cpp +++ b/VolTriZmapVolume.cpp @@ -18,15 +18,10 @@ #include "VolZmap.h" #include "GeoConst.h" #include "IntersLineSurfTm.h" -#include "\EgtDev\Include\EgtNumUtils.h" - +#include "/EgtDev/Include/EgtNumUtils.h" using namespace std ; - - - - // ------------------------- OPERAZIONI SU INTERVALLI -------------------------------------------------------------------------------------- //---------------------------------------------------------------------------- @@ -34,20 +29,19 @@ bool VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) { - - // Controllo che dMin e dMax non siano quasi coincidenti + // Controllo che dMin e dMax non siano quasi coincidenti if ( abs( dMax - dMin) < EPS_SMALL) return true ; - // Controllo che il numero di griglia sia entro i limiti + // Controllo che il numero di griglia sia entro i limiti if ( nGrid < 0 || nGrid > 2) return false ; - // Controllo che dMin < dMax + // Controllo che dMin < dMax if ( dMin > dMax) swap( dMin, dMax) ; - // Controllo che indici nI, nJ siano entro i limiti + // Controllo che indici nI, nJ siano entro i limiti if ( nI < 0 && nI >= m_nNx[nGrid] && nJ < 0 && nJ >= m_nNy[nGrid]) return false ; @@ -68,81 +62,119 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ swap( vtNma.x, vtNma.z) ; } - // Calcolo nPos + // Calcolo nPos unsigned int nPos = nJ * m_nNx[nGrid] + nI ; - // Ciclo sugli intervalli del singolo dexel + // Ciclo sugli intervalli del singolo dexel bool bModified = false ; unsigned int i = 0 ; - while ( i + 1 < m_Values[nGrid][nPos].size()) { - - // Casi: - // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione - if ( m_Values[nGrid][nPos][i].dZVal > dMax - EPS_SMALL) { + while ( i < m_Values[nGrid][nPos].size()) { + // Casi: + // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione + if ( m_Values[nGrid][nPos][i].dMin > dMax - EPS_SMALL) { ; } - // Intersezione - else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax + EPS_SMALL) { - // L'intervallo corrente corrente viene limitato a sinistra - if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { + // Intersezione + else if ( m_Values[nGrid][nPos][i].dMax > dMax + EPS_SMALL) { + // L'intervallo corrente viene limitato a sinistra + if ( m_Values[nGrid][nPos][i].dMin > dMin - EPS_SMALL) { bModified = true ; - m_Values[nGrid][nPos][i].dZVal = dMax ; - m_Values[nGrid][nPos][i].vtN = vtNma ; + // Aggiornamento dati del tratto di dexel + m_Values[nGrid][nPos][i].dMin = dMax ; + m_Values[nGrid][nPos][i].vtMinN = vtNma ; + m_Values[nGrid][nPos][i].nToolMin = m_nCurrentToolNum ; } - // L'intervallo si divide in due intervalli + // L'intervallo si divide in due intervalli else { bModified = true ; - m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ; + // Aumento la dimensione del dexel + m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 1) ; - for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 3 ; -- j) { - - m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ; - m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ; + size_t nStartT = max( 0, int( m_Values[nGrid][nPos].size()) - 1) ; + + // Sposto i tratti successivi a quello corrente in avanti di una posizione + for ( size_t j = nStartT ; j >= i + 2 ; -- j) { + // Quote estreme + m_Values[nGrid][nPos][j].dMax = m_Values[nGrid][nPos][j - 1].dMax ; + m_Values[nGrid][nPos][j].dMin = m_Values[nGrid][nPos][j - 1].dMin ; + // Normali + m_Values[nGrid][nPos][j].vtMaxN = m_Values[nGrid][nPos][j - 1].vtMaxN ; + m_Values[nGrid][nPos][j].vtMinN = m_Values[nGrid][nPos][j - 1].vtMinN ; + // Numero utensile + m_Values[nGrid][nPos][j].nToolMax = m_Values[nGrid][nPos][j - 1].nToolMax ; + m_Values[nGrid][nPos][j].nToolMin = m_Values[nGrid][nPos][j - 1].nToolMin ; + // Indice di componente + m_Values[nGrid][nPos][j].nCompo = m_Values[nGrid][nPos][j - 1].nCompo ; } - m_Values[nGrid][nPos][i + 1].dZVal = dMin ; - m_Values[nGrid][nPos][i + 2].dZVal = dMax ; + // Divido in due il tratto corrente - m_Values[nGrid][nPos][i + 1].vtN = vtNmi ; - m_Values[nGrid][nPos][i + 2].vtN = vtNma ; + // Parte superiore + m_Values[nGrid][nPos][i + 1].dMax = m_Values[nGrid][nPos][i].dMax ; + m_Values[nGrid][nPos][i + 1].vtMaxN = m_Values[nGrid][nPos][i].vtMaxN ; + m_Values[nGrid][nPos][i + 1].nToolMax = m_Values[nGrid][nPos][i].nToolMax ; + m_Values[nGrid][nPos][i + 1].dMin = dMax ; + m_Values[nGrid][nPos][i + 1].vtMinN = vtNma ; + m_Values[nGrid][nPos][i + 1].nToolMin = m_nCurrentToolNum ; + m_Values[nGrid][nPos][i + 1].nCompo = m_Values[nGrid][nPos][i].nCompo ; - i = i + 2 ; + // Parte inferiore + m_Values[nGrid][nPos][i].dMax = dMin ; + m_Values[nGrid][nPos][i].vtMaxN = vtNmi ; + m_Values[nGrid][nPos][i].nToolMax = m_nCurrentToolNum ; + + i = i + 1 ; } } - else { - // L'intervallo corrente viene eliminato - if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { - bModified = true ; - for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 2 ; ++ j) { - m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j + 2].dZVal ; - m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j + 2].vtN ; + else { + // L'intervallo corrente viene eliminato + if ( m_Values[nGrid][nPos][i].dMin > dMin - EPS_SMALL) { + bModified = true ; + // Sposto i tratti successivi a quello corrente indietro di una posizione + for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 1 ; ++ j) { + + m_Values[nGrid][nPos][j].dMin = m_Values[nGrid][nPos][j + 1].dMin ; + m_Values[nGrid][nPos][j].dMax = m_Values[nGrid][nPos][j + 1].dMax ; + + m_Values[nGrid][nPos][j].vtMinN = m_Values[nGrid][nPos][j + 1].vtMinN ; + m_Values[nGrid][nPos][j].vtMaxN = m_Values[nGrid][nPos][j + 1].vtMaxN ; + + m_Values[nGrid][nPos][j].nToolMin = m_Values[nGrid][nPos][j + 1].nToolMin ; + m_Values[nGrid][nPos][j].nToolMax = m_Values[nGrid][nPos][j + 1].nToolMax ; + + m_Values[nGrid][nPos][j].nCompo = m_Values[nGrid][nPos][j + 1].nCompo ; } - m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 2) ; + // Riduco la dimensione del dexel + m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 1) ; - i = i - 2 ; + i = i - 1 ; } - // L'intervallo corrente viene limitato a destra - else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin + EPS_SMALL) { + // L'intervallo corrente viene limitato a destra + else if ( m_Values[nGrid][nPos][i].dMax > dMin + EPS_SMALL) { bModified = true ; - m_Values[nGrid][nPos][i + 1].dZVal = dMin ; - m_Values[nGrid][nPos][i + 1].vtN = vtNmi ; + m_Values[nGrid][nPos][i].dMax = dMin ; + m_Values[nGrid][nPos][i].vtMaxN = vtNmi ; + m_Values[nGrid][nPos][i].nToolMax = m_nCurrentToolNum ; } - // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione + // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione else { ; } } - i = i + 2 ; + i = i + 1 ; } - // Se eseguita modifica, imposto ricalcolo della grafica + // Se eseguita modifica, imposto ricalcolo della grafica if ( bModified) { - // Determino quali blocchi sono stati modificati + // Dichiaro numero di componenti connesse da ricalcolare + m_nConnectedCompoCount = - 1 ; + + // Determino quali blocchi sono stati modificati int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ; if ( nGrid == 0) { @@ -157,17 +189,9 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nDexNumPBlock)) ; for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) { - /* for ( int nIndX = nXBlock - 1 ; nIndX <= nXBlock + 1 ; nIndX ++) { - for ( int nIndY = nYBlock - 1 ; nIndY <= nYBlock + 1 ; nIndY ++) {*/ - - /*if ( nIndX >= 0 && nIndX < int( m_nFracLin[0]) && - nIndY >= 0 && nIndY < int( m_nFracLin[1])) {*/ - + int nBlockNum = k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock ; - m_BlockToUpdate[nBlockNum] = true ; - /* } - } - }*/ + m_BlockToUpdate[nBlockNum] = true ; } } else if ( nGrid == 1) { @@ -182,17 +206,8 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nDexNumPBlock)) ; for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) { - /* for( int nIndY = nYBlock - 1 ; nIndY <= nYBlock + 1 ; ++ nIndY) { - for ( int nIndZ = nZBlock - 1 ; nIndZ <= nZBlock + 1 ; ++ nIndZ) { - - if ( nIndY >= 0 && nIndY < int( m_nFracLin[1]) && - nIndZ >= 0 && nIndZ < int( m_nFracLin[2])) {*/ - - int nBlockNum = nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k ; - m_BlockToUpdate[nBlockNum] = true ; - /* } - } - }*/ + int nBlockNum = nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k ; + m_BlockToUpdate[nBlockNum] = true ; } } else if ( nGrid == 2) { @@ -207,17 +222,9 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nDexNumPBlock)) ; for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) { - /* for ( int nIndX = nXBlock - 1 ; nIndX <= nXBlock + 1 ; ++ nIndX) { - for ( int nIndZ = nZBlock - 1 ; nIndZ <= nZBlock + 1 ; ++ nIndZ) { - - if ( nIndX >= 0 && nIndX < int( m_nFracLin[0]) && - nIndZ >= 0 && nIndZ < int( m_nFracLin[2])) { - */ - int nBlockNum = nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock ; - m_BlockToUpdate[nBlockNum] = true ; - /* } - } - }*/ + + int nBlockNum = nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock ; + m_BlockToUpdate[nBlockNum] = true ; } } @@ -269,217 +276,229 @@ bool VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) { - // Controllo che dMin e dMax non siano quasi coincidenti - if ( abs( dMax - dMin) < EPS_SMALL) - return true ; - - // Controllo che il numero di griglia sia entro i limiti - if ( nGrid < 0 || nGrid > 2) - return false ; - - // Controllo che dMin < dMax - if ( dMin > dMax) - swap( dMin, dMax) ; - - // Controllo che indici nI, nJ siano entro i limiti - if ( nI < 0 && nI >= m_nNx[nGrid] && - nJ < 0 && nJ >= m_nNy[nGrid]) - return false ; - - // Riporto le coordinate cicliche nell'ordine di partenza - Vector3d vtNmi = vtNMin ; - Vector3d vtNma = vtNMax ; - if ( nGrid == 1) { - swap( vtNmi.x, vtNmi.z) ; - swap( vtNmi.y, vtNmi.z) ; - swap( vtNma.x, vtNma.z) ; - swap( vtNma.y, vtNma.z) ; - } - else if ( nGrid == 2) { - swap( vtNmi.y, vtNmi.z) ; - swap( vtNmi.x, vtNmi.z) ; - swap( vtNma.y, vtNma.z) ; - swap( vtNma.x, vtNma.z) ; - } - - // Calcolo nPos - unsigned int nPos = nJ * m_nNx[nGrid] + nI ; - - - // Se spillone vuoto - if ( m_Values[nGrid][nPos].size() == 0) { - - m_Values[nGrid][nPos].resize( 2) ; - - m_Values[nGrid][nPos][0].dZVal = dMin ; - m_Values[nGrid][nPos][1].dZVal = dMax ; - - m_Values[nGrid][nPos][0].vtN = vtNmi ; - m_Values[nGrid][nPos][1].vtN = vtNma ; - - if ( dMax > m_dMaxZ[nGrid]) - m_dMinZ[nGrid] = dMax ; - - if ( dMin < m_dMinZ[nGrid]) - m_dMinZ[nGrid] = dMin ; - - m_OGrMgr.Reset() ; - - return true ; - } - - // Ciclo sugli intervalli dello spillone - bool bModified = false ; - unsigned int i = 0 ; - while ( i + 1 < m_Values[nGrid][nPos].size()) { - - // Eventuale aggiustamento di intervalli sovrapposti - if ( i > 0) { - - if ( m_Values[nGrid][nPos][i].dZVal < m_Values[nGrid][nPos][i - 1].dZVal + EPS_SMALL) { - - // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva - if ( m_Values[nGrid][nPos][i - 1].dZVal < m_Values[nGrid][nPos][i + 1].dZVal + EPS_SMALL) { - - m_Values[nGrid][nPos][i - 1].dZVal = m_Values[nGrid][nPos][i + 1].dZVal ; - m_Values[nGrid][nPos][i - 1].vtN = m_Values[nGrid][nPos][i + 1].vtN ; - } - - for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 2 ; ++ j) { - - m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j + 2].dZVal ; - m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j + 2].vtN ; - } - - m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 2) ; - - i = i - 2 ; - } - } - - // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente - if ( m_Values[nGrid][nPos][i].dZVal > dMax + EPS_SMALL) { - - bModified = true ; - - m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ; - - for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) { - - m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ; - m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ; - } - - - m_Values[nGrid][nPos][i].dZVal = dMin ; - m_Values[nGrid][nPos][i + 1].dZVal = dMax ; - - m_Values[nGrid][nPos][i].vtN = vtNMin ; - m_Values[nGrid][nPos][i + 1].vtN = vtNMax ; - - i = i + 2 ; - } - - // Casi d'intersezione: - else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax - EPS_SMALL) { - - // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente - if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { - - bModified = true ; - m_Values[nGrid][nPos][i].dZVal = dMin ; - m_Values[nGrid][nPos][i].vtN = vtNmi ; - } - } - - else { - // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi - if ( m_Values[nGrid][nPos][i].dZVal > dMin + EPS_SMALL) { - - bModified = true ; - m_Values[nGrid][nPos][i].dZVal = dMin ; - m_Values[nGrid][nPos][i + 1].dZVal = dMax ; - m_Values[nGrid][nPos][i].vtN = vtNMin ; - m_Values[nGrid][nPos][i + 1].vtN = vtNma ; - } - // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente - else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin - EPS_SMALL) { - - bModified = true ; - m_Values[nGrid][nPos][i + 1].dZVal = dMax ; - m_Values[nGrid][nPos][i + 1].vtN = vtNma ; - } - else { - // Aggiungo intervallo a destra dell'ultimo intervallo - if ( i == m_Values[nGrid][nPos].size() - 2) { - - bModified = true ; - m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ; - - m_Values[nGrid][nPos][i + 2].dZVal = dMin ; - m_Values[nGrid][nPos][i + 3].dZVal = dMax ; - m_Values[nGrid][nPos][i + 2].vtN = vtNmi ; - m_Values[nGrid][nPos][i + 3].vtN = vtNma ; - - i = i + 2 ; - } - } - } - - i = i + 2 ; - } - - // se eseguita modifica, imposto ricalcolo della grafica - if ( bModified) { - - // Determino quali blocchi sono stati modificati - int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ; - - if ( nGrid == 0) { - - int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ; - int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ; - int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; - int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; - - for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) - - m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ; - } - else if ( nGrid == 1) { - - int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ; - int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ; - int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; - int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; - - for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) - - m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ; - } - else if ( nGrid == 2) { - - int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ; - int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ; - int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; - int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; - - for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) - - m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ; - } - - m_OGrMgr.Reset() ; - - // Aggiorno massima e minima Z - // sullo Zmap - if ( dMax > m_dMaxZ[nGrid]) - m_dMinZ[nGrid] = dMax ; - - if ( dMin < m_dMinZ[nGrid]) - m_dMinZ[nGrid] = dMin ; - } - +// // Controllo che dMin e dMax non siano quasi coincidenti +// if ( abs( dMax - dMin) < EPS_SMALL) +// return true ; +// +// // Controllo che il numero di griglia sia entro i limiti +// if ( nGrid < 0 || nGrid > 2) +// return false ; +// +// // Controllo che dMin < dMax +// if ( dMin > dMax) +// swap( dMin, dMax) ; +// +// // Controllo che indici nI, nJ siano entro i limiti +// if ( nI < 0 && nI >= m_nNx[nGrid] && +// nJ < 0 && nJ >= m_nNy[nGrid]) +// return false ; +// +// // Riporto le coordinate cicliche nell'ordine di partenza +// Vector3d vtNmi = vtNMin ; +// Vector3d vtNma = vtNMax ; +// if ( nGrid == 1) { +// swap( vtNmi.x, vtNmi.z) ; +// swap( vtNmi.y, vtNmi.z) ; +// swap( vtNma.x, vtNma.z) ; +// swap( vtNma.y, vtNma.z) ; +// } +// else if ( nGrid == 2) { +// swap( vtNmi.y, vtNmi.z) ; +// swap( vtNmi.x, vtNmi.z) ; +// swap( vtNma.y, vtNma.z) ; +// swap( vtNma.x, vtNma.z) ; +// } +// +// // Calcolo nPos +// unsigned int nPos = nJ * m_nNx[nGrid] + nI ; +// +// +// // Se spillone vuoto +// if ( m_Values[nGrid][nPos].size() == 0) { +// +// m_Values[nGrid][nPos].resize( 1) ; +// +// m_Values[nGrid][nPos][0].dMin = dMin ; +// m_Values[nGrid][nPos][0].dMax = dMax ; +// +// m_Values[nGrid][nPos][0].vtMinN = vtNmi ; +// m_Values[nGrid][nPos][0].vtMaxN = vtNma ; +// +// if ( dMax > m_dMaxZ[nGrid]) +// m_dMinZ[nGrid] = dMax ; +// +// if ( dMin < m_dMinZ[nGrid]) +// m_dMinZ[nGrid] = dMin ; +// +// m_OGrMgr.Reset() ; +// +// return true ; +// } +// +// // Ciclo sugli intervalli dello spillone +// bool bModified = false ; +// unsigned int i = 0 ; +// while ( i < m_Values[nGrid][nPos].size()) { +// +// // Eventuale aggiustamento di intervalli sovrapposti +// if ( i < m_Values[nGrid][nPos].size() - 1) { +// if ( m_Values[nGrid][nPos][i].dMax > m_Values[nGrid][nPos][i + 1].dMin - EPS_SMALL) { +// +// // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva +// if ( m_Values[nGrid][nPos][i].dMin < m_Values[nGrid][nPos][i + 1].dMin + EPS_SMALL) { +// +// m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i + 1].dMax ; +// m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i + 1].vtMaxN ; +// } +// // altrimenti +// else { +// +// m_Values[nGrid][nPos][i].dMin = m_Values[nGrid][nPos][i].dMin ; +// m_Values[nGrid][nPos][i].vtMinN = m_Values[nGrid][nPos][i].vtMinN ; +// +// m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i].dMax ; +// m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i].vtMaxN ; +// } +// +// for ( unsigned int j = i + 1 ; j < m_Values[nGrid][nPos].size() - 1 ; ++ j) { +// +// m_Values[nGrid][nPos][j].dMin = m_Values[nGrid][nPos][j + 1].dMin ; +// m_Values[nGrid][nPos][j].vtMinN = m_Values[nGrid][nPos][j + 1].vtMinN ; +// +// m_Values[nGrid][nPos][j].dMax = m_Values[nGrid][nPos][j + 1].dMax ; +// m_Values[nGrid][nPos][j].vtMaxN = m_Values[nGrid][nPos][j + 1].vtMaxN ; +// } +// +// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 1) ; +// +// i = i - 1 ; +// } +// } +// +// +// // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente +// if ( m_Values[nGrid][nPos][i].dZVal > dMax + EPS_SMALL) { +// +// bModified = true ; +// +// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ; +// +// for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) { +// +// m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ; +// m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ; +// } +// +// +// m_Values[nGrid][nPos][i].dZVal = dMin ; +// m_Values[nGrid][nPos][i + 1].dZVal = dMax ; +// +// m_Values[nGrid][nPos][i].vtN = vtNMin ; +// m_Values[nGrid][nPos][i + 1].vtN = vtNMax ; +// +// i = i + 2 ; +// } +// +// // Casi d'intersezione: +// else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax - EPS_SMALL) { +// +// // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente +// if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { +// +// bModified = true ; +// m_Values[nGrid][nPos][i].dZVal = dMin ; +// m_Values[nGrid][nPos][i].vtN = vtNmi ; +// } +// } +// +// else { +// // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi +// if ( m_Values[nGrid][nPos][i].dZVal > dMin + EPS_SMALL) { +// +// bModified = true ; +// m_Values[nGrid][nPos][i].dZVal = dMin ; +// m_Values[nGrid][nPos][i + 1].dZVal = dMax ; +// m_Values[nGrid][nPos][i].vtN = vtNMin ; +// m_Values[nGrid][nPos][i + 1].vtN = vtNma ; +// } +// // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente +// else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin - EPS_SMALL) { +// +// bModified = true ; +// m_Values[nGrid][nPos][i + 1].dZVal = dMax ; +// m_Values[nGrid][nPos][i + 1].vtN = vtNma ; +// } +// else { +// // Aggiungo intervallo a destra dell'ultimo intervallo +// if ( i == m_Values[nGrid][nPos].size() - 2) { +// +// bModified = true ; +// m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ; +// +// m_Values[nGrid][nPos][i + 2].dZVal = dMin ; +// m_Values[nGrid][nPos][i + 3].dZVal = dMax ; +// m_Values[nGrid][nPos][i + 2].vtN = vtNmi ; +// m_Values[nGrid][nPos][i + 3].vtN = vtNma ; +// +// i = i + 2 ; +// } +// } +// } +// +// i = i + 2 ; +// } +// +// // se eseguita modifica, imposto ricalcolo della grafica +// if ( bModified) { +// +// // Determino quali blocchi sono stati modificati +// int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ; +// +// if ( nGrid == 0) { +// +// int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ; +// int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ; +// int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; +// int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; +// +// for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) +// +// m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ; +// } +// else if ( nGrid == 1) { +// +// int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ; +// int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ; +// int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; +// int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; +// +// for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) +// +// m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ; +// } +// else if ( nGrid == 2) { +// +// int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ; +// int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ; +// int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ; +// int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ; +// +// for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) +// +// m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ; +// } +// +// m_OGrMgr.Reset() ; +// +// // Aggiorno massima e minima Z +// // sullo Zmap +// if ( dMax > m_dMaxZ[nGrid]) +// m_dMinZ[nGrid] = dMax ; +// +// if ( dMin < m_dMinZ[nGrid]) +// m_dMinZ[nGrid] = dMin ; +// } +// return true ; } @@ -488,35 +507,35 @@ bool VolZmap::AddIntervals( unsigned int nGrid, const Point3d & ptP, double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) { - // Controllo che il numero di griglia sia entro i limiti. - if ( nGrid < 0 || nGrid > 2) - return false ; - - // ptP è espresso nel sistema locale e viene convertito in quello intrinseco (localFrame) - Point3d ptPL = ptP ; - ptPL.ToLoc( m_MapFrame[nGrid]) ; - - double dX, dY, dZ ; // Coordinate di ptPL nel sistema intrinseco - double dhMin, dhMax ; // Altezze dMin e dMax RIESPRESSE nel sistema intrinseco (dMin e dMax sono altezze rispetto a ptP) - - dX = ptPL.x ; dY = ptPL.y ; dZ = ptPL.z ; - dhMin = dZ + dMin ; dhMax = dZ + dMax ; - - // Cerco il punto della griglia più vicino - double integerPartX = floor( dX / m_dStep) ; - double integerPartY = floor( dY / m_dStep) ; - - unsigned int i = static_cast (integerPartX) ; // Indici del punto di griglia più vicino. - unsigned int j = static_cast (integerPartY) ; // i = 0, 1, ..., m_Nx - 1 ; j = 0, 1, ..., m_Ny - 1 - - // Controllo che gli indici ottenuti siano nella griglia: - // se sono dentro la griglia chiamo l'altra add - if ( i >= 0 && i < m_nNx[nGrid] && - j >= 0 && j < m_nNy[nGrid]) - - return AddIntervals( nGrid, i, j, dhMin, dhMax, vtNMin, vtNMax) ; - else - // altrimenti non succede niente +// // Controllo che il numero di griglia sia entro i limiti. +// if ( nGrid < 0 || nGrid > 2) +// return false ; +// +// // ptP è espresso nel sistema locale e viene convertito in quello intrinseco (localFrame) +// Point3d ptPL = ptP ; +// ptPL.ToLoc( m_MapFrame[nGrid]) ; +// +// double dX, dY, dZ ; // Coordinate di ptPL nel sistema intrinseco +// double dhMin, dhMax ; // Altezze dMin e dMax RIESPRESSE nel sistema intrinseco (dMin e dMax sono altezze rispetto a ptP) +// +// dX = ptPL.x ; dY = ptPL.y ; dZ = ptPL.z ; +// dhMin = dZ + dMin ; dhMax = dZ + dMax ; +// +// // Cerco il punto della griglia più vicino +// double integerPartX = floor( dX / m_dStep) ; +// double integerPartY = floor( dY / m_dStep) ; +// +// unsigned int i = static_cast (integerPartX) ; // Indici del punto di griglia più vicino. +// unsigned int j = static_cast (integerPartY) ; // i = 0, 1, ..., m_Nx - 1 ; j = 0, 1, ..., m_Ny - 1 +// +// // Controllo che gli indici ottenuti siano nella griglia: +// // se sono dentro la griglia chiamo l'altra add +// if ( i >= 0 && i < m_nNx[nGrid] && +// j >= 0 && j < m_nNy[nGrid]) +// +// return AddIntervals( nGrid, i, j, dhMin, dhMax, vtNMin, vtNMax) ; +// else +// // altrimenti non succede niente return false ; } @@ -779,11 +798,13 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point if ( vtToolDir.z > 0) { Vector3d vtNorm = Point3d( ptSxy.x, ptSxy.y, dMinStemZ) - Point3d( dX, dY, dMinStemZ - dH) ; + vtNorm.Normalize() ; SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ, vtNorm, - vtToolDir) ; } else { Vector3d vtNorm = Point3d( ptSxy.x, ptSxy.y, dMinStemZ) - Point3d( dX, dY, dMinStemZ + dH) ; + vtNorm.Normalize() ; SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH, - vtToolDir, vtNorm) ; } } @@ -1898,6 +1919,9 @@ VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Poin Vector3d vtMin = ptF - Point3d( dX, dY, dMin) ; Vector3d vtMax = ptF - Point3d( dX, dY, dMax) ; + vtMin.Normalize() ; + vtMax.Normalize() ; + SubtractIntervals( nGrid, i, j, dZ - dH, dZ + dH, vtMin, vtMax) ; } } @@ -2299,6 +2323,9 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3 Vector3d vtNmin = ( ptI - ptIntMin) - ( ptI - ptIntMin) * vtV1 * vtV1 ; Vector3d vtNmax = ( ptI - ptIntMax) - ( ptI - ptIntMax) * vtV1 * vtV1 ; + vtNmin.Normalize() ; + vtNmax.Normalize() ; + SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH, vtNmin, vtNmax) ; } else if ( dX1 >= dMatStemLen && @@ -3387,12 +3414,19 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3 dMax = dZMaxI + dDeltaZ * ( dX1 + dX1_0) / dLenXY ; - Vector3d vtCirc = dX1_0 * vtV1 - dX2 * vtV2 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtMove ; + if ( abs( vtMove * vtToolDir) < EPS_SMALL) { + + vtMax = - Z_AX ; + } + else { + + Vector3d vtCirc = dX1_0 * vtV1 - dX2 * vtV2 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtMove ; - vtMax = ( vtCross * vtCirc > - EPS_ZERO ? vtCross : - vtCross) ; - vtMax.Normalize() ; + vtMax = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; + vtMax.Normalize() ; + } } // Minimo if ( dX1 * dX1 + dX2 * dX2 < dSqRad) { @@ -3405,12 +3439,19 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3 dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ; - Vector3d vtCirc = - dX1_0 * vtV1 - dX2 * vtV2 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtMove ; + if ( abs( vtMove * vtToolDir) < EPS_SMALL) { - vtMin = ( vtCross * vtCirc > - EPS_ZERO ? vtCross : - vtCross) ; - vtMin.Normalize() ; + vtMin = Z_AX ; + } + else { + + Vector3d vtCirc = - dX1_0 * vtV1 - dX2 * vtV2 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtMove ; + + vtMin = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; + vtMin.Normalize() ; + } } SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ; } @@ -3512,7 +3553,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dPLim = dZI + dDeltaZ ; - vtP = - vtToolDir ; + vtP = - vtV1 ; } else { @@ -3520,12 +3561,19 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dPLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; - Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtUmv ; + if ( abs( vtV1 * vtUmv) < EPS_SMALL) { + + vtP = - vtV1 ; + } + else { + + Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtUmv ; - vtP = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; - vtP.Normalize() ; + vtP = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; + vtP.Normalize() ; + } } // Limiti nella direzione negativa di vtV1 @@ -3553,14 +3601,21 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin double dIDL_0 = sqrt( dMaxRad * dMaxRad - dIDO * dIDO) ; - dMLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; + dMLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; - Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtUmv ; + if ( abs( vtUmv * vtV1) < EPS_SMALL) { + + vtM = vtV1 ; + } + else { + + Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtUmv ; - vtM = ( vtCross * vtMove > 0 ? vtCross : - vtCross) ; - vtM.Normalize() ; + vtM = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; + vtM.Normalize() ; + } } } else { @@ -3570,7 +3625,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dPLim = dZI + dDeltaZ ; - vtP = - vtToolDir ; + vtP = - vtV1 ; } else { @@ -3578,13 +3633,20 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dPLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; - Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtUmv ; - //////////////////////////////////////////////////////////////////////////////////////// - vtP = ( vtCross * vtCirc > - EPS_ZERO ? vtCross : - vtCross) ; // vtCross * vtCirc o vtCross * vtMove? - //////////////////////////////////////////////////////////////////////////////////////// - vtP.Normalize() ; + if ( abs( vtUmv * vtToolDir) < EPS_SMALL) { + + vtP = - vtV1 ; + } + else { + + Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtUmv ; + //////////////////////////////////////////////////////////////////////////////////////// + vtP = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; // vtCross * vtCirc o vtCross * vtMove? + //////////////////////////////////////////////////////////////////////////////////////// + vtP.Normalize() ; + } } // Limiti nella direzione negativa di vtV1 @@ -3592,7 +3654,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dMLim = dZTI ; - vtM = vtToolDir ; + vtM = vtV1 ; } else if ( dSqDI >= dMinRad * dMinRad && dSqDI < dMaxRad * dMaxRad && dIVarCos < dCos) { @@ -3621,13 +3683,22 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin double dIDL_0 = sqrt( dMinRad * dMinRad - dIDO * dIDO) ; dMLim = dZTI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; + + if ( abs( vtUmv * vtV1) < EPS_SMALL) { + + vtM = vtV1 ; + } + else { - Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtUmv ; - - vtM = ( vtCross * vtMove > - EPS_ZERO ? vtCross : - vtCross) ; - vtM.Normalize() ; + Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtUmv ; + + double dDotCrossCirc = vtCross * vtCirc ; + + vtM = ( dDotCrossCirc > 0 ? vtCross : - vtCross) ; + vtM.Normalize() ; + } } else if ( dIDO >= dMinRad * dSin && dIDO < dMaxRad * dSin) { @@ -3644,13 +3715,19 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dMLim = dZTI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; - Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtUmv ; + if ( abs( vtUmv * vtV1) < EPS_SMALL) { + + vtM = vtV1 ; + } + else { - vtM = ( vtCross * vtMove > - EPS_ZERO ? vtCross : - vtCross) ; - vtM.Normalize() ; - + Vector3d vtCirc = - dIDL_0 * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtUmv ; + + vtM = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ; + vtM.Normalize() ; + } } else { @@ -3673,13 +3750,19 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin dMLim = dZI + ( dIDL - dIDL_0) * dDeltaZ / dLOrt ; - Vector3d vtCirc = - dIDL * vtV2 - dIDO * vtV3 ; - Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; - Vector3d vtCross = vtTan ^ vtMove ; - - - vtM = ( vtCross * vtMove > - EPS_ZERO ? vtCross : - vtCross) ; - vtM.Normalize() ; + if ( abs( vtUmv * vtV1) < EPS_SMALL) { + + vtM = vtV1 ; + } + else { + + Vector3d vtCirc = - dIDL * vtV2 - dIDO * vtV3 ; + Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ; + Vector3d vtCross = vtTan ^ vtMove ; + + vtM = ( vtCross * vtMove > 0 ? vtCross : - vtCross) ; + vtM.Normalize() ; + } } } @@ -3952,14 +4035,9 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { - - if ( i == 4 && j == 2) - int bau = 0 ; - - + Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - - + Point3d ptInt1, ptInt2 ; Vector3d vtN1, vtN2 ; diff --git a/VolZmap.cpp b/VolZmap.cpp index 3681e1c..0cc6aaf 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -2,7 +2,7 @@ // EgalTech 2015-2016 //---------------------------------------------------------------------------- // File : VolZmap.cpp Data : 22.01.15 Versione : 1.6a4 -// Contenuto : Implementazione della classe Volume Zmap (singola griglia) +// Contenuto : Implementazione della classe Volume Zmap (tre griglie) // // // @@ -18,7 +18,9 @@ #include "NgeWriter.h" #include "NgeReader.h" #include "GeoConst.h" -#include "\EgtDev\Include\EGkIntervals.h" +#include "/EgtDev/Include/EGkUiUnits.h" +#include "/EgtDev/Include/EGkIntervals.h" +#include "/EgtDev/Include/EGkStringUtils3d.h" using namespace std ; @@ -33,6 +35,7 @@ VolZmap::VolZmap(void) { m_nMapNum = 0 ; m_nNumBlock = 0 ; + m_nConnectedCompoCount = 0 ; for ( int i = 0 ; i < N_MAPS ; ++ i) { m_nNx[i] = 0 ; m_nNy[i] = 0 ; @@ -54,6 +57,8 @@ VolZmap::Clear( void) { m_nStatus = TO_VERIFY ; m_nMapNum = 0 ; + m_nNumBlock = 0 ; + m_nConnectedCompoCount = 0 ; for ( int i = 0 ; i < N_MAPS ; ++ i) { m_MapFrame[i].Reset() ; m_nNx[i] = 0 ; @@ -107,9 +112,14 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc) { if ( &vzmSrc == this) return true ; - m_OGrMgr.Reset() ; m_nMapNum = vzmSrc.m_nMapNum ; + m_nNumBlock = vzmSrc.m_nNumBlock ; + m_nDexNumPBlock = vzmSrc.m_nDexNumPBlock ; + m_nFracLin[0] = vzmSrc.m_nFracLin[0] ; + m_nFracLin[1] = vzmSrc.m_nFracLin[1] ; + m_nFracLin[2] = vzmSrc.m_nFracLin[2] ; + m_nConnectedCompoCount = vzmSrc.m_nConnectedCompoCount ; for ( int i = 0 ; i < int ( m_nMapNum) ; ++ i) { @@ -128,6 +138,24 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc) m_dStep = vzmSrc.m_dStep ; m_nStatus = vzmSrc.m_nStatus ; m_nTempProp = vzmSrc.m_nTempProp ; + + // dimensiono membri legati ai blocchi + m_BlockToUpdate.resize( m_nNumBlock) ; + m_InterBlockTria.resize( m_nNumBlock) ; + + // imposto ricalcolo grafica + ResetGraphics() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +VolZmap::ResetGraphics( void) +{ + m_OGrMgr.Reset() ; + for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) + m_BlockToUpdate[nCount] = true ; return true ; } @@ -150,7 +178,24 @@ VolZmap::GetTitle( void) const bool VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const { - return false ; + // tipo + sOut += "Type=" + string( m_nMapNum == 1 ? "dexel" : "tridexel") + szNewLine ; + // passo + sOut += "Step=" + ToString( GetInUiUnits( m_dStep, bMM), 3) + szNewLine ; + // dimensioni + if ( m_nMapNum == 1) + sOut += "Dim=" + ToString( m_nDim[0]) + + "(" + ToString( m_nNx[0]) + "x" + ToString( m_nNy[0]) + ")" + szNewLine ; + else { + for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) + sOut += "Dim" + ToString( i+1) + "=" + ToString( m_nDim[i]) + + "(" + ToString( m_nNx[i]) + "x" + ToString( m_nNy[i]) + ")" + szNewLine ; + } + // numero di blocchi + sOut += "Blocks=" + ToString( m_nNumBlock) + " (" + ToString( m_nFracLin[0]) + "x" + + ToString( m_nFracLin[1]) + "x" + ToString( m_nFracLin[2]) + ")" + szNewLine ; + + return true ; } //---------------------------------------------------------------------------- @@ -165,7 +210,24 @@ bool VolZmap::Save( NgeWriter& ngeOut) const { // numero di mappe - if ( ! ngeOut.WriteInt( m_nMapNum, ";", true)) + if ( ! ngeOut.WriteInt( m_nMapNum, ",", false)) + return false ; + // numero di blocchi + if ( ! ngeOut.WriteInt( m_nNumBlock, ",", false)) + return false ; + // numero di dexel per blocco + if ( ! ngeOut.WriteInt( m_nDexNumPBlock, ",", false)) + return false ; + // numero di blocchi per ogni asse + for ( int i = 0 ; i < 3 ; ++ i) { + if ( ! ngeOut.WriteInt( m_nFracLin[i], ",", false)) + return false ; + } + // numero di componenti connesse + if ( ! ngeOut.WriteInt( m_nConnectedCompoCount, ",", false)) + return false ; + // passo di campionamento (distanza tra spilloni) + if ( ! ngeOut.WriteDouble( m_dStep, ";", true)) return false ; // per ogni mappa : sistema di riferimento, numero di passi in X e Y intrinseci for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { @@ -173,19 +235,20 @@ VolZmap::Save( NgeWriter& ngeOut) const return false ; if ( ! ngeOut.WriteInt( m_nNx[i], ",", false)) return false ; - if ( ! ngeOut.WriteInt( m_nNy[i], ";", true)) + if ( ! ngeOut.WriteInt( m_nNy[i], ",", false)) + return false ; + if ( ! ngeOut.WriteDouble( m_dMinZ[i], ",", false)) + return false ; + if ( ! ngeOut.WriteDouble( m_dMaxZ[i], ";", true)) return false ; } - // passo di campionamento (distanza tra spilloni) - if ( ! ngeOut.WriteDouble( m_dStep, ";", true)) - return false ; // ciclo sulle mappe for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { // ciclo sui dexel for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { // numero di estremi unsigned int nDim = unsigned int( m_Values[i][j].size()) ; - if ( ! ngeOut.WriteInt( nDim, ",", false)) + if ( ! ngeOut.WriteInt( nDim, ":", false)) return false ; // se dexel nullo if ( nDim == 0) { @@ -196,8 +259,19 @@ VolZmap::Save( NgeWriter& ngeOut) const // altrimenti else { for ( unsigned int k = 0 ; k < nDim ; ++ k) { - bool bEndL = ( k == nDim - 1) ; - if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dZVal, ( bEndL ? ";" : ","), bEndL)) + if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMin, ",", false)) + return false ; + if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMin, ";", false)) + return false ; + if ( ! ngeOut.WriteVector( m_Values[i][j][k].vtMinN, ";", false)) + return false ; + if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMax, ",", false)) + return false ; + if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMax, ";", false)) + return false ; + if ( ! ngeOut.WriteVector( m_Values[i][j][k].vtMaxN, ";", false)) + return false ; + if ( ! ngeOut.WriteInt( m_Values[i][j][k].nCompo, ";", true)) return false ; } } @@ -212,7 +286,24 @@ VolZmap::Load( NgeReader& ngeIn) { Clear() ; // numero di mappe - if ( ! ngeIn.ReadInt( m_nMapNum, ";", true)) + if ( ! ngeIn.ReadInt( m_nMapNum, ",", false)) + return false ; + // numero di blocchi + if ( ! ngeIn.ReadInt( m_nNumBlock, ",", false)) + return false ; + // numero di dexel per blocco + if ( ! ngeIn.ReadInt( m_nDexNumPBlock, ",", false)) + return false ; + // numero di blocchi per ogni asse + for ( int i = 0 ; i < 3 ; ++ i) { + if ( ! ngeIn.ReadInt( m_nFracLin[i], ",", false)) + return false ; + } + // numero di componenti connesse + if ( ! ngeIn.ReadInt( m_nConnectedCompoCount, ",", false)) + return false ; + // passo di campionamento (distanza tra spilloni) + if ( ! ngeIn.ReadDouble( m_dStep, ";", true)) return false ; // per ogni mappa : sistema di riferimento, numero di passi in X e Y intrinseci for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { @@ -220,13 +311,14 @@ VolZmap::Load( NgeReader& ngeIn) return false ; if ( ! ngeIn.ReadInt( m_nNx[i], ",", false)) return false ; - if ( ! ngeIn.ReadInt( m_nNy[i], ";", true)) + if ( ! ngeIn.ReadInt( m_nNy[i], ",", false)) return false ; m_nDim[i] = m_nNx[i] * m_nNy[i] ; + if ( ! ngeIn.ReadDouble( m_dMinZ[i], ",", false)) + return false ; + if ( ! ngeIn.ReadDouble( m_dMaxZ[i], ";", true)) + return false ; } - // passo di campionamento (distanza tra spilloni) - if ( ! ngeIn.ReadDouble( m_dStep, ";", true)) - return false ; // ciclo sulle mappe for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) { // dimensiono i vettori @@ -235,11 +327,8 @@ VolZmap::Load( NgeReader& ngeIn) for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) { // leggo il numero di estremi nel dexel unsigned int nDim ; - if ( ! ngeIn.ReadInt( nDim, ",", false)) - return false ; - // devono essere pari - if ( ( nDim % 2) != 0) - return false ; + if ( ! ngeIn.ReadInt( nDim, ":", false)) + return false ; // se dexel nullo if ( nDim == 0) { // leggo un valore dummy @@ -252,14 +341,33 @@ VolZmap::Load( NgeReader& ngeIn) // dimensiono l'array m_Values[i][j].resize( nDim) ; // leggo i valori - for ( unsigned int k = 0 ; k < nDim ; ++ k) { - bool bEndL = ( k == nDim - 1) ; - if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dZVal, ( bEndL ? ";" : ","), bEndL)) + for ( unsigned int k = 0 ; k < nDim ; ++ k) { + if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMin, ",", false)) + return false ; + if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMin, ";", false)) + return false ; + if ( ! ngeIn.ReadVector( m_Values[i][j][k].vtMinN, ";", false)) + return false ; + if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMax, ",", false)) + return false ; + if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMax, ";", false)) + return false ; + if ( ! ngeIn.ReadVector( m_Values[i][j][k].vtMaxN, ";", false)) + return false ; + if ( ! ngeIn.ReadInt( m_Values[i][j][k].nCompo, ";", true)) return false ; } } } } + + // imposto aggiornamento obbligatorio su tutti i blocchi + m_BlockToUpdate.resize( m_nNumBlock) ; + for ( unsigned int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount) + m_BlockToUpdate[nCount] = true ; + + // per triangoli di feature di frontiera tra blocchi + m_InterBlockTria.resize( m_nNumBlock) ; m_nStatus = OK ; return true ; @@ -293,8 +401,8 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const size_t nPos = ic + jc * m_nNx[0] ; if ( m_Values[0][nPos].size() > 0) { Point3d ptP = m_MapFrame[0].Orig() + dX * m_MapFrame[0].VersX() + dY * m_MapFrame[0].VersY() ; - b3Loc.Add( ptP + m_Values[0][nPos][0].dZVal * m_MapFrame[0].VersZ()) ; - b3Loc.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dZVal * m_MapFrame[0].VersZ()) ; + b3Loc.Add( ptP + m_Values[0][nPos][0].dMin * m_MapFrame[0].VersZ()) ; + b3Loc.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dMax * m_MapFrame[0].VersZ()) ; } // passo al punto successivo dX += m_dStep ; @@ -302,7 +410,7 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const // passo alla riga successiva dY += m_dStep ; } - +// return true ; } @@ -337,8 +445,8 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const size_t nPos = ic + jc * m_nNx[0] ; if ( m_Values[0][nPos].size() > 0) { Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ; - b3Ref.Add( ptP + m_Values[0][nPos][0].dZVal * frUse.VersZ()) ; - b3Ref.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dZVal * frUse.VersZ()) ; + b3Ref.Add( ptP + m_Values[0][nPos][0].dMin * frUse.VersZ()) ; + b3Ref.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dMax * frUse.VersZ()) ; } // passo al punto successivo dX += m_dStep ; @@ -358,7 +466,7 @@ VolZmap::Translate( const Vector3d& vtMove) if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica - m_OGrMgr.Reset() ; + ResetGraphics() ; // traslo i riferimenti for ( int i = 0 ; i < int( m_nMapNum) ; ++ i) m_MapFrame[i].Translate( vtMove) ; @@ -373,7 +481,7 @@ VolZmap::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, doub if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica - m_OGrMgr.Reset() ; + ResetGraphics() ; // ruoto i riferimenti for ( int i = 0 ; i < int( m_nMapNum) ; ++ i) m_MapFrame[i].Rotate( ptAx, vtAx, dCosAng, dSinAng) ; @@ -418,7 +526,7 @@ VolZmap::ToGlob( const Frame3d& frRef) if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica - m_OGrMgr.Reset() ; + ResetGraphics() ; // trasformo il riferimento for ( int i = 0 ; i < int ( m_nMapNum) ; ++ i) m_MapFrame[i].ToGlob( frRef) ; @@ -433,7 +541,7 @@ VolZmap::ToLoc( const Frame3d& frRef) if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica - m_OGrMgr.Reset() ; + ResetGraphics() ; // trasformo il riferimento for ( int i = 0 ; i < int( m_nMapNum) ; ++ i) m_MapFrame[i].ToLoc( frRef) ; @@ -448,13 +556,31 @@ VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest) if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica - m_OGrMgr.Reset() ; + ResetGraphics() ; // trasformo il riferimento for ( int i = 0 ; i < int( m_nMapNum) ; ++ i) m_MapFrame[i].LocToLoc( frOri, frDest) ; return true ; } +//---------------------------------------------------------------------------- +bool +VolZmap::IsMapConnected( void) +{ + // Imposto a 0 tutti il valore del numero della componente + // connessa di ciascun tratto di ciascun dexel. + for ( size_t tMap = 0 ; tMap < m_nMapNum ; ++ tMap) { + for ( size_t tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) { + for ( size_t tInt = 0 ; tInt < m_Values[tMap][tDex].size() ; ++ tInt) { + m_Values[tMap][tDex][tInt].nCompo = 0 ; + } + } + } + return true ; +} + + + diff --git a/VolZmap.h b/VolZmap.h index 87e5f9f..a458ca4 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -116,6 +116,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW private : bool CopyFrom( const VolZmap& clSrc) ; + bool ResetGraphics( void) ; bool GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DLIST& lstTria) const ; bool CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const ; bool CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const ; @@ -149,7 +150,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW // Asse di simmetria parallelo a Z bool CylBall_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; bool CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; - bool CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d& vtToolDir) ; + bool CylBall_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; bool Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; bool Conus_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ; @@ -264,10 +265,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool IsATriangleOnBorder( const Triangle3d& trTria, const Point3d& ptVert, const int nBlockLimits[], const int nVoxIJK[], bool bBorderBox) const ; + // Connessione Zmap + bool IsMapConnected( void) ; + private : enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ; static const int N_MAPS = 3 ; - static const int N_DEXBLOCK = 32 ; // 10000 ; // 20 ; // 32 ; + static const int N_DEXBLOCK = 32 ; private : ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto @@ -282,9 +286,14 @@ class VolZmap : public IVolZmap, public IGeoObjRW double m_dMinZ[N_MAPS] ; // minimo in Zlocale di ciascuna griglia double m_dMaxZ[N_MAPS] ; // massimo in Zlocale di ciascuna griglia - struct Data { // Struttura dati: estremi del dexel e versori normali - double dZVal ; - Vector3d vtN ; + struct Data { // Tratto di dexel : dati estremi, versori normali e corpo di appartenenza + double dMin ; + int nToolMin ; + Vector3d vtMinN ; + double dMax ; + int nToolMax ; + Vector3d vtMaxN ; + int nCompo ; } ; std::vector> m_Values[N_MAPS] ; // dexel delle 3 griglie @@ -294,11 +303,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW unsigned int m_nNumBlock ; // Numero totale di blocchi mutable std::vector m_BlockToUpdate ; + + int m_nConnectedCompoCount ; // Se == - 1 il numero di componenti non è noto + // Se >= 0 è il numero di componenti connesse double m_dLinTol ; // Dati per utensile double m_dAngTolDeg ; std::string m_sToolName ; unsigned int m_nToolType ; + unsigned int m_nCurrentToolNum ; CurveComposite m_ToolOutline ; CurveComposite m_ToolArcLineApprox ; double m_dHeight ; diff --git a/VolZmapTool.cpp b/VolZmapTool.cpp index c5b0e48..efd3317 100644 --- a/VolZmapTool.cpp +++ b/VolZmapTool.cpp @@ -2,7 +2,7 @@ // EgalTech 2015-2016 //---------------------------------------------------------------------------- // File : VolZmap.cpp Data : 22.01.15 Versione : 1.6a4 -// Contenuto : Implementazione della classe Volume Zmap (singola griglia) +// Contenuto : Implementazione della classe Volume Zmap (utensili) // // // @@ -17,8 +17,8 @@ #include "CurveArc.h" #include "VolZmap.h" #include "GeoConst.h" -#include "\EgtDev\Include\EGKLinePntTgCurve.h" -#include "\EgtDev\Include\EGKFilletChamfer.h" +#include "/EgtDev/Include/EGKLinePntTgCurve.h" +#include "/EgtDev/Include/EGKFilletChamfer.h" using namespace std ; @@ -88,6 +88,8 @@ VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCorn return false ; // assegno il nome m_sToolName = sToolName ; + // Aggiorno il numero dell'utensile corrente + m_nCurrentToolNum = 0 ; return true ; } @@ -207,6 +209,8 @@ VolZmap::SetAdvTool( const string& sToolName, double dH, double dR, } // assegno il nome m_sToolName = sToolName ; + // Aggiorno il numero dell'utensile corrente + m_nCurrentToolNum = 0 ; return true ; } @@ -220,6 +224,9 @@ VolZmap::SetGenTool( const string& sToolName, const ICurveComposite* pToolOutlin // Aggiorno il tipo di utensile m_nToolType = GenericTool ; + // Aggiorno il numero dell'utensile corrente + m_nCurrentToolNum = 0 ; + // Copio il profilo m_ToolOutline.CopyFrom( pToolOutline) ;