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

EgtGeomKernel 1.9i3 :

Browse Source 
- versione NGE portata a 1014
- modifiche per velocizzare il calcolo della grafica di un VolZmap se box.
This commit is contained in:
Dario Sassi
2018-09-18 09:48:54 +00:00
parent 4f0a5e600f
commit c809b8e6bc
9 changed files with 512 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapGraphics.cpp
+410 -61
View File
@@ -166,6 +166,90 @@ DotTest( const AppliedVector CompoField[], int nCompoElem, Vector3d& vtAvg, doub
return true ;
}
//----------------------------------------------------------------------------
bool
CreateBigTriangleXY( double dMinX, double dMaxX, double dMinY, double dMaxY, double dZ,
bool bNormZPlus, int nGrade, Triangle3dEx& trTria1, Triangle3dEx& trTria2)
{
// Punti che definiscono il perimetro del rettangolo
Point3d ptP0( dMinX, dMinY, dZ) ;
Point3d ptP1( dMinX, dMaxY, dZ) ;
Point3d ptP2( dMaxX, dMaxY, dZ) ;
Point3d ptP3( dMaxX, dMinY, dZ) ;
// Versore normale diretto come Z+
if ( bNormZPlus) {
trTria1.Set( ptP0, ptP2, ptP1) ;
trTria2.Set( ptP0, ptP3, ptP2) ;
}
// Versore normale diretto come Z-
else {
trTria1.Set( ptP0, ptP1, ptP2) ;
trTria2.Set( ptP0, ptP2, ptP3) ;
}
trTria1.SetGrade( nGrade) ;
trTria2.SetGrade( nGrade) ;
return trTria1.Validate( true) && trTria2.Validate( true) ;
}
//----------------------------------------------------------------------------
bool
CreateBigTriangleXZ( double dMinX, double dMaxX, double dMinZ, double dMaxZ, double dY,
bool bNormYPlus, int nGrade, Triangle3dEx& trTria1, Triangle3dEx& trTria2)
{
// Punti che definiscono il perimetro del rettangolo
Point3d ptP0( dMinX, dY, dMinZ) ;
Point3d ptP1( dMinX, dY, dMaxZ) ;
Point3d ptP2( dMaxX, dY, dMaxZ) ;
Point3d ptP3( dMaxX, dY, dMinZ) ;
// Versore normale diretto come Y+
if ( bNormYPlus) {
trTria1.Set( ptP0, ptP1, ptP2) ;
trTria2.Set( ptP0, ptP2, ptP3) ;
}
// Versore normale diretto come Y-
else {
trTria1.Set( ptP0, ptP2, ptP1) ;
trTria2.Set( ptP0, ptP3, ptP2) ;
}
trTria1.SetGrade( nGrade) ;
trTria2.SetGrade( nGrade) ;
return trTria1.Validate( true) && trTria2.Validate( true) ;
}
//----------------------------------------------------------------------------
bool
CreateBigTriangleYZ( double dMinY, double dMaxY, double dMinZ, double dMaxZ, double dX,
bool bNormXPlus, int nGrade, Triangle3dEx& trTria1, Triangle3dEx& trTria2)
{
// Punti che definiscono il perimetro del rettangolo
Point3d ptP0( dX, dMinY, dMinZ) ;
Point3d ptP1( dX, dMinY, dMaxZ) ;
Point3d ptP2( dX, dMaxY, dMaxZ) ;
Point3d ptP3( dX, dMaxY, dMinZ) ;
// Versore normale diretto come X+
if ( bNormXPlus) {
trTria1.Set( ptP0, ptP2, ptP1) ;
trTria2.Set( ptP0, ptP3, ptP2) ;
}
// Versore normale diretto come X-
else {
trTria1.Set( ptP0, ptP1, ptP2) ;
trTria2.Set( ptP0, ptP2, ptP3) ;
}
trTria1.SetGrade( nGrade) ;
trTria2.SetGrade( nGrade) ;
return trTria1.Validate( true) && trTria2.Validate( true) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::FindAdjComp( const vector<VoxelContainer>& vVecVox, int nCurBlock, int nCurVox, int nCurComp,
@@ -1304,7 +1388,10 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV
for ( int i = nLimits[0] ; i < nLimits[1] ; ++ i) {
for ( int j = nLimits[2] ; j < nLimits[3] ; ++ j) {
for ( int k = nLimits[4] ; k < nLimits[5] ; ++ k) {
if ( m_nShape == BOX && ! IsVoxelOnBoxEdge( i, j, k))
continue ;
// Classificazione dei vertici: interni o esterni al materiale
int nIndex = CalcIndex( i, j, k) ;
@@ -1393,58 +1480,60 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV
}
// Controllo se il voxel ha una sola faccia che giace in un piano canonico e quindi ha gestione speciale
// Faccia XY normale Z+
if ( nIndex == 15) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Z_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXYSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
if ( m_nShape != BOX) {
// Faccia XY normale Z+
if ( nIndex == 15) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Z_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXYSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
// Faccia YZ normale X+
else if ( nIndex == 153) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], X_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContYZSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
// Faccia YZ normale X+
else if ( nIndex == 153) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], X_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContYZSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
// Faccia ZX normale Y+
else if ( nIndex == 51) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Y_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXZSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
// Faccia ZX normale Y+
else if ( nIndex == 51) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Y_PLUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXZSup.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
// Faccia YX normale Z-
else if ( nIndex == 240) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Z_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXYInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
// Faccia YX normale Z-
else if ( nIndex == 240) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Z_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXYInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
// Faccia ZY normale X-
else if ( nIndex == 102) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], X_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContYZInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
// Faccia ZY normale X-
else if ( nIndex == 102) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], X_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContYZInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
// Faccia XZ normale Y-
else if ( nIndex == 204) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Y_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXZInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
// Faccia XZ normale Y-
else if ( nIndex == 204) {
int nTool ; double dPos ;
if ( CanonicPlaneTest( CompoVert[0], Y_MINUS, dPos, nTool)) {
int nN ; GetVoxNFromIJK( i, j, k, nN) ;
VoxContXZInf.emplace( nN, HeigthAndColor( nTool, dPos)) ;
continue ;
}
}
}
@@ -1938,7 +2027,7 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV
VoxConf.Compo[tOldCompo].bCorner = ( nFeatureType == CORNER) ;
}
// Standard MC
else {
else if ( m_nShape != BOX) {
vector<Triangle3dEx> vTria ;
// Costruzione dei triangoli
for ( int TriIndex = 0; TriIndex < ( nVertComp[nComp] - 2) * 3 ; TriIndex += 3) {
@@ -2004,14 +2093,165 @@ VolZmap::ExtMarchingCubes( int nBlock, TRIA3DEXLIST& lstTria, VoxelContainer& vV
}
}
// Se il solido è un parallelepipedo creo direttamente i triangoli grandi
if ( m_nShape == BOX) {
int nBlockIJK[3] ;
GetBlockIJKFromN( nBlock, nBlockIJK) ;
// Determino il primo nodo pieno della mappa
int nFirstVoxI, nFirstVoxJ, nFirstVoxK ;
GetFirstVoxIJK( nFirstVoxI, nFirstVoxJ, nFirstVoxK) ;
// Determino il primo nodo pieno della mappa
int nLastVoxI, nLastVoxJ, nLastVoxK ;
GetLastVoxIJK( nLastVoxI, nLastVoxJ, nLastVoxK) ;
// Costruisco i triangoli paralleli al piano YZ
if ( nBlockIJK[0] == 0 || nBlockIJK[0] + 1 == m_nFracLin[0]) {
// Determino coordinate minime dei punti dei triangoli
double dYMin, dZMin ;
if ( nBlockIJK[1] > 0)
dYMin = ( nBlockIJK[1] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dYMin = ( ( nFirstVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[2] > 0)
dZMin = ( nBlockIJK[2] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dZMin = ( ( nFirstVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ; ;
// Determino le coordinate massime dei punti dei triangoli
double dYMax, dZMax ;
if ( nBlockIJK[1] + 1 < int( m_nFracLin[1]))
dYMax = ( ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dYMax = ( nLastVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[2] + 1 < int( m_nFracLin[2]))
dZMax = ( ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dZMax = ( nLastVoxK * N_DEXVOXRATIO + 0.5) * m_dStep ;
// Determino colore dei triangoli
int nDexMinJ = N_DEXVOXRATIO * ( nFirstVoxJ + 1) ;
int nDexMinK = N_DEXVOXRATIO * ( nFirstVoxK + 1) ;
int nFaceInfGrade = m_Values[1][nDexMinK * m_nNx[1] + nDexMinJ][0].nToolMin ;
int nFaceSupGrade = m_Values[1][nDexMinK * m_nNx[1] + nDexMinJ][0].nToolMax ;
// Piano di coordinata x inferiore: versore normale rivolto come X-
if ( nBlockIJK[0] == 0) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleYZ( dYMin, dYMax, dZMin, dZMax, m_dMinZ[1], false, nFaceInfGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
// Piano di coordinata x superiore: versore normale rivolto come X+
if ( nBlockIJK[0] + 1 == m_nFracLin[0]) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleYZ( dYMin, dYMax, dZMin, dZMax, m_dMaxZ[1], true, nFaceSupGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
}
// Costruisco i triangoli paralleli al piano XZ
if ( nBlockIJK[1] == 0 || nBlockIJK[1] + 1 == m_nFracLin[1]) {
// Determino coordinate minime dei punti dei triangoli
double dXMin, dZMin ;
if ( nBlockIJK[0] > 0)
dXMin = ( nBlockIJK[0] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dXMin = ( ( nFirstVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[2] > 0)
dZMin = ( nBlockIJK[2] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dZMin = ( ( nFirstVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ; ;
// Determino le coordinate massime dei punti dei triangoli
double dXMax, dZMax ;
if ( nBlockIJK[0] + 1 < int( m_nFracLin[0]))
dXMax = ( ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dXMax = ( nLastVoxI * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[2] + 1 < int( m_nFracLin[2]))
dZMax = ( ( nBlockIJK[2] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dZMax = ( nLastVoxK * N_DEXVOXRATIO + 0.5) * m_dStep ;
// Determino colore dei triangoli
int nDexMinI = N_DEXVOXRATIO * ( nFirstVoxI + 1) ;
int nDexMinK = N_DEXVOXRATIO * ( nFirstVoxK + 1) ;
int nFaceInfGrade = m_Values[2][nDexMinI * m_nNx[2] + nDexMinK][0].nToolMin ;
int nFaceSupGrade = m_Values[2][nDexMinI * m_nNx[2] + nDexMinK][0].nToolMax ;
// Piano di coordinata y inferiore: versore normale rivolto come Y-
if ( nBlockIJK[1] == 0) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleXZ( dXMin, dXMax, dZMin, dZMax, m_dMinZ[2], false, nFaceInfGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
// Piano di coordinata y superiore: versore normale rivolto come Y+
if ( nBlockIJK[1] + 1 == m_nFracLin[1]) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleXZ( dXMin, dXMax, dZMin, dZMax, m_dMaxZ[2], true, nFaceSupGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
}
// Costruisco i triangoli paralleli al piano XY
if ( nBlockIJK[2] == 0 || nBlockIJK[2] + 1 == m_nFracLin[2]) {
// Determino coordinate minime dei punti dei triangoli
double dXMin, dYMin ;
if ( nBlockIJK[0] > 0)
dXMin = ( nBlockIJK[0] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dXMin = ( ( nFirstVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[1] > 0)
dYMin = ( nBlockIJK[1] * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dYMin = ( ( nFirstVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep ;
// Determino le coordinate massime dei punti dei triangoli
double dXMax, dYMax ;
if ( nBlockIJK[0] + 1 < int( m_nFracLin[0]))
dXMax = ( ( nBlockIJK[0] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dXMax = ( nLastVoxI * N_DEXVOXRATIO + 0.5) * m_dStep ;
if ( nBlockIJK[1] + 1 < int( m_nFracLin[1]))
dYMax = ( ( nBlockIJK[1] + 1) * m_nVoxNumPerBlock * N_DEXVOXRATIO + 0.5) * m_dStep ;
else
dYMax = ( nLastVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep ;
// Determino colore dei triangoli
int nDexMinI = N_DEXVOXRATIO * ( nFirstVoxI + 1) ;
int nDexMinJ = N_DEXVOXRATIO * ( nFirstVoxJ + 1) ;
int nFaceInfGrade = m_Values[0][nDexMinJ * m_nNx[0] + nDexMinI][0].nToolMin ;
int nFaceSupGrade = m_Values[0][nDexMinJ * m_nNx[0] + nDexMinI][0].nToolMax ;
// Piano di coordinata Z inferiore: versore normale rivolto come Z-
if ( nBlockIJK[2] == 0) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleXY( dXMin, dXMax, dYMin, dYMax, m_dMinZ[0], false, nFaceInfGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
// Piano di coordinata Z superiore: versore normale rivolto come Z+
if ( nBlockIJK[2] + 1 == m_nFracLin[2]) {
Triangle3dEx trTria1, trTria2 ;
CreateBigTriangleXY( dXMin, dXMax, dYMin, dYMax, m_dMaxZ[0], true, nFaceSupGrade, trTria1, trTria2) ;
trTria1.ToGlob( m_MapFrame) ;
trTria2.ToGlob( m_MapFrame) ;
lstTria.emplace_back( trTria1) ;
lstTria.emplace_back( trTria2) ;
}
}
}
// Processo i Voxel con possibile superficie piana
ProcessVoxContXY( VoxContXYInf, false, lstTria) ;
ProcessVoxContXY( VoxContXYSup, true, lstTria) ;
ProcessVoxContYZ( VoxContYZInf, false, lstTria) ;
ProcessVoxContYZ( VoxContYZSup, true, lstTria) ;
ProcessVoxContXZ( VoxContXZInf, false, lstTria) ;
ProcessVoxContXZ( VoxContXZSup, true, lstTria) ;
else {
ProcessVoxContXY( VoxContXYInf, false, lstTria) ;
ProcessVoxContXY( VoxContXYSup, true, lstTria) ;
ProcessVoxContYZ( VoxContYZInf, false, lstTria) ;
ProcessVoxContYZ( VoxContYZSup, true, lstTria) ;
ProcessVoxContXZ( VoxContXZInf, false, lstTria) ;
ProcessVoxContXZ( VoxContXZSup, true, lstTria) ;
}
return true ;
}
@@ -2412,8 +2652,7 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel, T
// Valido il triangolo
CurrTri.Validate( true) ;
// Smisto i triangoli fra di frontiera e interni
bool bTriOnBorder = IsATriangleOnBorder( CurrTri, itVox->second.Compo[nComp].ptVert,
nLimits, nVoxIJK) ;
bool bTriOnBorder = IsTriangleOnBorder( CurrTri, nLimits, nVoxIJK) ;
// Triangolo di frontiera
if ( bTriOnBorder) {
if ( bNewCompBor) {
@@ -3491,9 +3730,119 @@ VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], int nDeltaIn
}
//----------------------------------------------------------------------------
// Per riferimento restituisce i minimi degli indici ijk riferiti ai Voxel.
// Si assume che il volume sia un parallelepipedo.
bool
VolZmap::IsATriangleOnBorder( const Triangle3dEx& trTria, const Point3d& ptVert,
const int nBlockLimits[], const int nVoxIJK[]) const
VolZmap::GetFirstVoxIJK( int& i, int& j, int& k) const
{
// Se non è un parallelepipedo, errore
if ( m_nShape != BOX)
return false ;
// Calcolo indici
int ni, nj ;
for ( ni = 0 ; ni < 2 ; ++ ni) {
bool bNotEmpty = false ;
for ( nj = 0 ; nj < 2 ; ++ nj) {
int nDex = nj * int( m_nNx[0]) + ni ;
if ( m_Values[0][nDex].size() > 0) {
bNotEmpty = true ;
break ;
}
}
if ( bNotEmpty)
break ;
}
int mi, mj ;
for ( mi = 0 ; mi < 2 ; ++ mi) {
bool bNotEmpty = false ;
for ( mj = 0 ; mj < 2 ; ++ mj) {
int nDex = mj * int( m_nNx[1]) + mi ;
if ( m_Values[1][nDex].size() > 0) {
bNotEmpty = true ;
break ;
}
}
if ( bNotEmpty)
break ;
}
i = ni / N_DEXVOXRATIO - ( ni % N_DEXVOXRATIO) - 1 ;
j = nj / N_DEXVOXRATIO - ( nj % N_DEXVOXRATIO) - 1 ;
k = mj / N_DEXVOXRATIO - ( mj % N_DEXVOXRATIO) - 1 ;
return true ;
}
//----------------------------------------------------------------------------
// Per riferimento restituisce i massimi degli indici ijk riferiti ai Voxel.
// Si assume che il volume sia un parallelepipedo.
bool
VolZmap::GetLastVoxIJK( int& i, int& j, int& k) const
{
// Se non è un parallelepipedo, errore
if ( m_nShape != BOX)
return false ;
// Calcolo indici
int ni, nj ;
for ( ni = int( m_nNx[0]) - 1 ; ni > int( m_nNx[0]) - 3 ; -- ni) {
bool bNotEmpty = false ;
for ( nj = int( m_nNy[0]) - 1 ; nj > int( m_nNy[0]) - 3 ; -- nj) {
int nDex = nj * int( m_nNx[0]) + ni ;
if ( m_Values[0][nDex].size() > 0) {
bNotEmpty = true ;
break ;
}
}
if ( bNotEmpty)
break ;
}
int mi, mj ;
for ( mi = int( m_nNx[1]) - 1 ; mi > int( m_nNx[1]) - 3 ; -- mi) {
bool bNotEmpty = false ;
for ( mj = int( m_nNy[1]) - 1 ; mj > int( m_nNy[1]) - 3 ; -- mj) {
int nDex = mj * int( m_nNx[1]) + mi ;
if ( m_Values[1][nDex].size() > 0) {
bNotEmpty = true ;
break ;
}
}
if ( bNotEmpty)
break ;
}
i = ni / N_DEXVOXRATIO ;
j = nj / N_DEXVOXRATIO ;
k = mj / N_DEXVOXRATIO ;
return true ;
}
//----------------------------------------------------------------------------
// Il volume deve essere un parallelepipedo.
// Verifica se il voxel contiene uno dei dodici spigoli del parallelepipedo.
bool
VolZmap::IsVoxelOnBoxEdge( int i, int j, int k) const
{
// Se non è un parallelepipedo, errore
if ( m_nShape != BOX)
return false ;
// Determino il primo nodo pieno della mappa
int nFirstVoxI, nFirstVoxJ, nFirstVoxK ;
GetFirstVoxIJK( nFirstVoxI, nFirstVoxJ, nFirstVoxK) ;
// Determino il primo nodo pieno della mappa
int nLastVoxI, nLastVoxJ, nLastVoxK ;
GetLastVoxIJK( nLastVoxI, nLastVoxJ, nLastVoxK) ;
// Determino se il voxel è su un edge del box
int nIndexOnLimitNum = 0 ;
if ( i == nFirstVoxI || i == nLastVoxI)
++ nIndexOnLimitNum ;
if ( j == nFirstVoxJ || j == nLastVoxJ)
++ nIndexOnLimitNum ;
if ( k == nFirstVoxK || k == nLastVoxK)
++ nIndexOnLimitNum ;
return ( nIndexOnLimitNum >= 2) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IsTriangleOnBorder( const Triangle3dEx& trTria, const int nBlockLimits[], const int nVoxIJK[]) const
{
// Punti del triangolo sulla griglia
Point3d ptFirstGrPt = trTria.GetP( 1) ;
@@ -3522,7 +3871,7 @@ VolZmap::IsATriangleOnBorder( const Triangle3dEx& trTria, const Point3d& ptVert,
bool
VolZmap::ProcessVoxContXY( FlatVoxelContainer& VoxContXY, bool bPlus, TRIA3DEXLIST& lstTria) const
{
for ( auto it = VoxContXY.begin() ;
for ( auto it = VoxContXY.cbegin() ;
it != VoxContXY.end() ;
it = VoxContXY.begin()) {