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

EgtGeomKernel 2.1c3 :

Browse Source 
- migliorie a Zmap per gestione colore standard/lavorato.
This commit is contained in:
Dario Sassi
2019-03-13 17:38:59 +00:00
parent aedd666121
commit d56a1feac5
2 changed files with 110 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
VolZmapGraphics.cpp
+110 -296
View File
@@ -169,13 +169,10 @@ CanonicPlaneTest( const AppliedVector CompoField[], int nDir, double& dPos, int&
return false ;
for ( int j = i + 1 ; j < 4 ; ++ j) {
if ( CompoField[i].nPropIndex != CompoField[j].nPropIndex)
++ nDifferent ;
else
nTool = CompoField[i].nPropIndex ;
return false ;
}
}
if ( nDifferent > 3)
return false ;
nTool = CompoField[0].nPropIndex ;
// Superati tutti i test
return true ;
}
@@ -2007,14 +2004,30 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
if ( bExtConfirmed) {
int tOldCompo = VoxConf.nNumComp ;
++ VoxConf.nNumComp ;
VoxConf.Compo[tOldCompo].nVertNum = nVertComp[nComp] ;
ConComp& CurFan = VoxConf.Compo[tOldCompo] ;
CurFan.nVertNum = nVertComp[nComp] ;
for ( int nV = 0 ; nV < nVertComp[nComp] ; ++ nV) {
VoxConf.Compo[tOldCompo].CompVecField[nV] = CompoVert[nComp][nV] ;
CurFan.CompVecField[nV] = CompoVert[nComp][nV] ;
}
VoxConf.Compo[tOldCompo].ptVert = ptSol ;
VoxConf.Compo[tOldCompo].vtNullSpace = vtNullSpace ;
VoxConf.Compo[tOldCompo].bInside = IsPointInsideVoxelApprox( i, j, k, ptSol, EPS_SMALL) ;
VoxConf.Compo[tOldCompo].bCorner = ( nFeatureType == CORNER) ;
for ( int nV = 0 ; nV < CurFan.nVertNum && CurFan.nVertNum >= 2 ; ++ nV) {
int nW = ( nV + 1) % CurFan.nVertNum ;
if ( AreSamePointApprox( CurFan.CompVecField[nV].ptPApp, CurFan.CompVecField[nW].ptPApp) &&
CurFan.CompVecField[nV].vtVec * CurFan.CompVecField[nW].vtVec > 0.9) {
Vector3d vtAvNorm = 0.5 * ( CurFan.CompVecField[nV].vtVec + CurFan.CompVecField[nW].vtVec) ;
vtAvNorm.Normalize() ;
CurFan.CompVecField[nV].ptPApp = 0.5 * ( CurFan.CompVecField[nV].ptPApp + CurFan.CompVecField[nW].ptPApp) ;
for ( int nL = nW ; nL < CurFan.nVertNum - 1 ; ++ nL) {
CurFan.CompVecField[nV].ptPApp = CurFan.CompVecField[nL + 1].ptPApp ;
CurFan.CompVecField[nL].vtVec = CurFan.CompVecField[nL + 1].vtVec ;
CurFan.CompVecField[nL].nPropIndex = CurFan.CompVecField[nL + 1].nPropIndex;
}
-- CurFan.nVertNum ;
}
}
CurFan.ptVert = ptSol ;
CurFan.vtNullSpace = vtNullSpace ;
CurFan.bInside = IsPointInsideVoxelApprox( i, j, k, ptSol, EPS_SMALL) ;
CurFan.bCorner = ( nFeatureType == CORNER) ;
}
// ExtMC non confermato
else
@@ -2468,265 +2481,6 @@ VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
}
return true ;
}
//bool
//VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
//{
// // Ciclo sui blocchi
// for ( int nBlock = 0 ; nBlock < int( m_nNumBlock) ; ++ nBlock) {
// // Se il blocco è da aggiornare
// if ( m_BlockToUpdate[nBlock]) {
// // Ciclo sui voxel interni
// for ( auto itVox = vVecVox[nBlock].begin() ; itVox != vVecVox[nBlock].end() ; ++ itVox) {
// int nVox ;
// Voxel& CurVox = itVox->second ;
// GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ;
// // Ciclo sulle componenti
// for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) {
// // Caso feature
// if ( ! CurVox.Compo[nComp].bCorner) {
// // Vertice fuori dal suo voxel
// if ( ! CurVox.Compo[nComp].bInside) {
// Point3d ptMin( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Point3d ptMax( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// double dU1, dU2 ;
// if ( IntersLineBox( CurVox.Compo[nComp].ptVert, CurVox.Compo[nComp].vtNullSpace, ptMin, ptMax, dU1, dU2)) {
// double dU = abs( dU1) < abs( dU2) ? dU1 : dU2 ;
// //CurVox.Compo[nComp].ptVert += ( dU * CurVox.Compo[nComp].vtNullSpace) ;
// }
// }
// }
// }
// }
// // Ciclo sui voxel di frontiera
// for ( auto itVox = m_InterBlockVox[nBlock].begin() ; itVox != m_InterBlockVox[nBlock].end() ; ++ itVox) {
// // int nVox ;
// // Voxel& CurVox = itVox->second ;
// // GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ;
// //// Ciclo sulle componenti
// // for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) {
// // // Vertice fuori dal suo voxel
// // if ( ! CurVox.Compo[nComp].bInside) {
// // // Caso feature
// // if ( ! CurVox.Compo[nComp].bCorner) {
// // INTVECTOR vNearInn, vNearBord ;
// // FindAdjComp( vVecVox, nBlock, nVox, nComp, vNearInn, vNearBord) ;
// // int nSizeInn = int( vNearInn.size()) ;
// // int nSizeBord = int( vNearBord.size() );
// // if ( nSizeInn + nSizeBord == 6) {
// // const Voxel* pVoxSt = nullptr ;
// // const Voxel* pVoxEn = nullptr ;
// // if ( nSizeInn == 6) {
// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ;
// // pVoxEn = &( vVecVox[vNearInn[3]].find( vNearInn[4])->second) ;
// // }
// // else if ( nSizeBord == 6) {
// // pVoxSt = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ;
// // pVoxEn = &( m_InterBlockVox[vNearBord[3]].find( vNearBord[4])->second) ;
// // }
// // else {
// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ;
// // pVoxEn = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ;
// // }
// // Point3d ptPCur = CurVox.Compo[nComp].ptVert ;
// // Point3d ptPSt ;
// // Point3d ptPEn ;
// // if ( nSizeInn == 6) {
// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearInn[5]].ptVert ;
// // }
// // else if ( nSizeBord == 6) {
// // ptPSt = pVoxSt->Compo[vNearBord[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearBord[5]].ptVert ;
// // }
// // else {
// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearBord[2]].ptVert ;
// // }
// // Vector3d vtStCurr = ptPCur - ptPSt ;
// // Vector3d vtStEn = ptPEn - ptPSt ;
// // Vector3d vtCurrEn = ptPEn - ptPCur ;
// // vtStCurr.Normalize() ;
// // vtStEn.Normalize() ;
// // vtCurrEn.Normalize() ;
// // Point3d ptMid = 0.5 * ( ptPSt + ptPEn) ;
// // double dMidU = ( ptMid - ptPSt) * vtStEn ;
// // double dCurU = ( ptPCur - ptPSt) * vtStEn ;
// // Point3d ptNew ;
// // Point3d ptPLine ;
// // Vector3d vtDLine ;
// // if ( dMidU < dCurU) {
// // ptPLine = ptPEn ;
// // vtDLine = - vtCurrEn ;
// // ptNew = ptPEn + ( ptMid - ptPEn) * vtCurrEn * vtCurrEn ;
// // }
// // else {
// // ptPLine = ptPSt ;
// // vtDLine = vtStCurr ;
// // ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ;
// // }
// // Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// // Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// // double dU1, dU2 ;
// // if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO &&
// // IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) {
// // double dU = abs( dU1) < abs( dU2) ? dU1 + ( dU2 - dU1) / 2 : dU2 + ( dU1 - dU2) / 2 ;
// // ptNew = ptPLine + dU * vtDLine ;
// // }
// // bool bNewInside = IsPointInsideVoxelApprox( CurVox.i, CurVox.j, CurVox.k, ptNew, 0) ;
// // if ( abs( vtStCurr * vtStEn) > 0.95 && abs( vtStCurr * vtCurrEn) > 0.95 &&
// // abs( vtStEn * vtCurrEn) > 0.95 /*&& bNewInside*/) {
// // CurVox.Compo[nComp].ptVert = ptNew ;
// // }
// // }
// // }
// // }
// // }
// }
// }
// }
// return true ;
//}
//bool
//VolZmap::RegulateFeaturesChain( vector<VoxelContainer>& vVecVox) const
//{
// // Ciclo sui blocchi
// for ( int nBlock = 0 ; nBlock < int( m_nNumBlock) ; ++ nBlock) {
// // Se il blocco è da aggiornare
// if ( m_BlockToUpdate[nBlock]) {
// // Ciclo sui voxel interni
// for ( auto itVox = vVecVox[nBlock].begin() ; itVox != vVecVox[nBlock].end() ; ++ itVox) {
// int nVox ;
// Voxel& CurVox = itVox->second ;
// GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ;
// // Ciclo sulle componenti
// for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) {
// // Caso feature
// if ( ! CurVox.Compo[nComp].bCorner) {
// // Vertice fuori dal suo voxel
// if ( ! CurVox.Compo[nComp].bInside) {
// int nPointVoxIJK[3] ;
// int nPointVoxN ;
// if ( GetPointVoxel( CurVox.Compo[nComp].ptVert, nPointVoxIJK[0], nPointVoxIJK[1], nPointVoxIJK[2]) &&
// GetVoxNFromIJK( nPointVoxIJK[0], nPointVoxIJK[1], nPointVoxIJK[2], nPointVoxN)) {
// auto itPointVox = vVecVox[nBlock].find( nPointVoxN) ;
// Voxel& PointVox = itPointVox->second ;
// for ( int nPoitVoxComp = 0 ; nPoitVoxComp < PointVox.nNumComp ; ++ nPoitVoxComp) {
// if ( ! PointVox.Compo[nPoitVoxComp].bCorner &&
// AreSameOrOppositeVectorApprox( CurVox.Compo[nComp].vtNullSpace,
// PointVox.Compo[nPoitVoxComp].vtNullSpace)) {
// Point3d ptAvLine = ( CurVox.Compo[nComp].ptVert + PointVox.Compo[nPoitVoxComp].ptVert) / 2 ;
// Vector3d vtS = CurVox.Compo[nComp].ptVert - ptAvLine ;
// vtS -= ( vtS * CurVox.Compo[nComp].vtNullSpace) * CurVox.Compo[nComp].vtNullSpace ;
// CurVox.Compo[nComp].ptVert -= vtS ;
// break ;
// }
// }
// }
// }
// }
// }
// }
// // Ciclo sui voxel di frontiera
// for ( auto itVox = m_InterBlockVox[nBlock].begin() ; itVox != m_InterBlockVox[nBlock].end() ; ++ itVox) {
// // int nVox ;
// // Voxel& CurVox = itVox->second ;
// // GetVoxNFromIJK( CurVox.i, CurVox.j, CurVox.k, nVox) ;
// //// Ciclo sulle componenti
// // for ( int nComp = 0 ; nComp < CurVox.nNumComp ; ++ nComp) {
// // // Vertice fuori dal suo voxel
// // if ( ! CurVox.Compo[nComp].bInside) {
// // // Caso feature
// // if ( ! CurVox.Compo[nComp].bCorner) {
// // INTVECTOR vNearInn, vNearBord ;
// // FindAdjComp( vVecVox, nBlock, nVox, nComp, vNearInn, vNearBord) ;
// // int nSizeInn = int( vNearInn.size()) ;
// // int nSizeBord = int( vNearBord.size() );
// // if ( nSizeInn + nSizeBord == 6) {
// // const Voxel* pVoxSt = nullptr ;
// // const Voxel* pVoxEn = nullptr ;
// // if ( nSizeInn == 6) {
// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ;
// // pVoxEn = &( vVecVox[vNearInn[3]].find( vNearInn[4])->second) ;
// // }
// // else if ( nSizeBord == 6) {
// // pVoxSt = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ;
// // pVoxEn = &( m_InterBlockVox[vNearBord[3]].find( vNearBord[4])->second) ;
// // }
// // else {
// // pVoxSt = &( vVecVox[vNearInn[0]].find( vNearInn[1])->second) ;
// // pVoxEn = &( m_InterBlockVox[vNearBord[0]].find( vNearBord[1])->second) ;
// // }
// // Point3d ptPCur = CurVox.Compo[nComp].ptVert ;
// // Point3d ptPSt ;
// // Point3d ptPEn ;
// // if ( nSizeInn == 6) {
// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearInn[5]].ptVert ;
// // }
// // else if ( nSizeBord == 6) {
// // ptPSt = pVoxSt->Compo[vNearBord[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearBord[5]].ptVert ;
// // }
// // else {
// // ptPSt = pVoxSt->Compo[vNearInn[2]].ptVert ;
// // ptPEn = pVoxEn->Compo[vNearBord[2]].ptVert ;
// // }
// // Vector3d vtStCurr = ptPCur - ptPSt ;
// // Vector3d vtStEn = ptPEn - ptPSt ;
// // Vector3d vtCurrEn = ptPEn - ptPCur ;
// // vtStCurr.Normalize() ;
// // vtStEn.Normalize() ;
// // vtCurrEn.Normalize() ;
// // Point3d ptMid = 0.5 * ( ptPSt + ptPEn) ;
// // double dMidU = ( ptMid - ptPSt) * vtStEn ;
// // double dCurU = ( ptPCur - ptPSt) * vtStEn ;
// // Point3d ptNew ;
// // Point3d ptPLine ;
// // Vector3d vtDLine ;
// // if ( dMidU < dCurU) {
// // ptPLine = ptPEn ;
// // vtDLine = - vtCurrEn ;
// // ptNew = ptPEn + ( ptMid - ptPEn) * vtCurrEn * vtCurrEn ;
// // }
// // else {
// // ptPLine = ptPSt ;
// // vtDLine = vtStCurr ;
// // ptNew = ptPSt + ( ptMid - ptPSt) * vtStCurr * vtStCurr ;
// // }
// // Point3d ptCubeInf( ( CurVox.i * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( CurVox.j * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( CurVox.k * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// // Point3d ptCubeSup( ( ( CurVox.i + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( ( CurVox.j + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
// // ( ( CurVox.k + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// // double dU1, dU2 ;
// // if ( 1 - abs( vtStCurr * vtCurrEn ) < EPS_ZERO &&
// // IntersLineBox( ptPLine, vtDLine, ptCubeInf, ptCubeSup, dU1, dU2)) {
// // double dU = abs( dU1) < abs( dU2) ? dU1 + ( dU2 - dU1) / 2 : dU2 + ( dU1 - dU2) / 2 ;
// // ptNew = ptPLine + dU * vtDLine ;
// // }
// // bool bNewInside = IsPointInsideVoxelApprox( CurVox.i, CurVox.j, CurVox.k, ptNew, 0) ;
// // if ( abs( vtStCurr * vtStEn) > 0.95 && abs( vtStCurr * vtCurrEn) > 0.95 &&
// // abs( vtStEn * vtCurrEn) > 0.95 /*&& bNewInside*/) {
// // CurVox.Compo[nComp].ptVert = ptNew ;
// // }
// // }
// // }
// // }
// // }
// }
// }
// }
// return true ;
//}
//----------------------------------------------------------------------------
// A partire dalla struttura dati di tipo voxel con sharp features crea i triangoli corrispondenti.
@@ -2892,30 +2646,35 @@ VolZmap::CreateSharpFeatureTriangle( int nBlock, const VoxelContainer& vVoxel) c
//----------------------------------------------------------------------------
bool
VolZmap::CreateSmoothTriangle( int nIndex, int nVertNum, AppliedVector TriVert[], bool bWasSharp, SmoothTriaStruct& VoxSmoothTria) const
VolZmap::CreateSmoothTriangle(int nIndex, int nVertNum, AppliedVector TriVert[], bool bWasSharp, SmoothTriaStruct& VoxSmoothTria) const
{
vector<Triangle3dEx> vTria ;
TRIA3DEXVECTOR vTria ;
// Costruzione dei triangoli
for ( int TriIndex = 0 ; TriIndex < ( nVertNum - 2) * 3 ; TriIndex += 3) {
for ( int TriIndex = 0 ; TriIndex < (nVertNum - 2) * 3 ; TriIndex += 3) {
// Il triangolo è pronto
Triangle3dEx CurrentTriangle ;
CurrentTriangle.Set( TriVert[TriIndex].ptPApp,
TriVert[TriIndex+1].ptPApp,
TriVert[TriIndex+2].ptPApp) ;
TriVert[TriIndex + 1].ptPApp,
TriVert[TriIndex + 2].ptPApp) ;
// Setto il numero di utensile (conta solo positivo, nullo o negativo)
int nTool0 = Clamp( TriVert[TriIndex].nPropIndex, -1, 1) ;
int nTool1 = Clamp( TriVert[TriIndex+1].nPropIndex, -1, 1) ;
int nTool2 = Clamp( TriVert[TriIndex+2].nPropIndex, -1, 1) ;
if ( nTool0 == nTool1 || nTool0 == nTool2)
CurrentTriangle.SetGrade( nTool0) ;
else if ( nTool1 == nTool2)
CurrentTriangle.SetGrade( nTool1) ;
int nTool0 = Clamp( TriVert[TriIndex].nPropIndex, - 1, 1) ;
int nTool1 = Clamp( TriVert[TriIndex + 1].nPropIndex, - 1, 1) ;
int nTool2 = Clamp( TriVert[TriIndex + 2].nPropIndex, - 1, 1) ;
int nGrade = 0 ;
if ( nTool0 == -1 || nTool1 == -1 || nTool2 == -1)
nGrade = -1 ;
else if ( nTool0 == 1 || nTool1 == 1 || nTool2 == 1)
nGrade = 1 ;
CurrentTriangle.SetGrade( nGrade) ;
CurrentTriangle.SetAttrib( 0, nTool0) ;
CurrentTriangle.SetAttrib( 1, nTool1) ;
CurrentTriangle.SetAttrib( 2, nTool2) ;
// Valido il triangolo e setto le normali del campo vettoriale ai corrispondenti vertici
if ( CurrentTriangle.Validate( true)) {
double dCosAngThreshold = bWasSharp ? 0.7 : 0.5 ;
if ( CurrentTriangle.Validate( true)) {
double dCosAngThreshold = ( bWasSharp ? 0.7 : 0.5) ;
for ( int nV = 0 ; nV < 3 ; ++ nV) {
const Vector3d& vtVertNorm = TriVert[TriIndex+nV].vtVec ;
if ( CurrentTriangle.GetN() * vtVertNorm > dCosAngThreshold)
const Vector3d& vtVertNorm = TriVert[TriIndex + nV].vtVec ;
if ( CurrentTriangle.GetN() * vtVertNorm > dCosAngThreshold)
CurrentTriangle.SetVertexNorm( nV, vtVertNorm) ;
else
CurrentTriangle.SetVertexNorm( nV, CurrentTriangle.GetN()) ;
@@ -2927,20 +2686,75 @@ VolZmap::CreateSmoothTriangle( int nIndex, int nVertNum, AppliedVector TriVert[]
vTria.emplace_back( CurrentTriangle) ;
}
// Controllo i colori di configurazioni 2 e 8
if ( ( nAllConfig[nIndex] == 2 || nAllConfig[nIndex] == 8) &&
vTria[0].GetN() * vTria[1].GetN() > 0.8) {
if ( vTria[0].GetGrade() < 0 || vTria[1].GetGrade() < 0) {
vTria[0].SetGrade( -1) ;
vTria[1].SetGrade( -1) ;
if ( nAllConfig[nIndex] == 2 || nAllConfig[nIndex] == 8) {
int nFst1 = - 1 ;
int nFst2 = - 1 ;
int nSec1 = - 1 ;
int nSec2 = - 1 ;
for ( int nF = 0 ; nF < 3 ; ++ nF) {
for ( int nS = 0 ; nS < 3 ; ++ nS) {
if ( AreSamePointExact( vTria[0].GetP( nF), vTria[1].GetP( nS))) {
if ( nFst1 < 0)
nFst1 = nF ;
else
nFst2 = nF ;
if ( nSec1 < 0)
nSec1 = nS ;
else
nSec2 = nS ;
}
}
}
else if ( vTria[0].GetGrade() > 0 || vTria[1].GetGrade() > 0) {
vTria[0].SetGrade( 1) ;
vTria[1].SetGrade( 1) ;
int nFst3 = -1 ;
int nSec3 = -1 ;
for ( int n = 0 ; n < 3 ; ++n) {
if ( n != nFst1 && n != nFst2)
nFst3 = n ;
if ( n != nSec1 && n != nSec2)
nSec3 = n ;
}
if ( vTria[0].GetAttrib( nFst1) != vTria[0].GetAttrib( nFst2) &&
vTria[0].GetAttrib( nFst3) == vTria[1].GetAttrib( nSec3)) {
vTria[0].SetP( nFst1, vTria[1].GetP( nSec3)) ;
vTria[0].SetAttrib( nFst1, vTria[1].GetAttrib( nSec3)) ;
vTria[0].SetVertexNorm( nFst1, vTria[1].GetVertexNorm( nSec3)) ;
int nFirstGrade = 0 ;
if ( vTria[0].GetAttrib(0) == -1 || vTria[0].GetAttrib(1) == -1 || vTria[0].GetAttrib(2) == -1)
nFirstGrade = -1 ;
else if ( vTria[0].GetAttrib(0) == 1 || vTria[0].GetAttrib(1) == 1 || vTria[0].GetAttrib(2) == 1)
nFirstGrade = 1 ;
vTria[0].SetGrade( nFirstGrade) ;
vTria[0].Validate( true) ;
vTria[1].SetP( nSec2, vTria[0].GetP( nFst3)) ;
vTria[1].SetAttrib( nSec2, vTria[0].GetAttrib( nFst3)) ;
vTria[1].SetVertexNorm( nSec2, vTria[0].GetVertexNorm( nFst3)) ;
int nSecondGrade = 0 ;
if ( vTria[1].GetAttrib(0) == -1 || vTria[1].GetAttrib(1) == -1 || vTria[1].GetAttrib(2) == -1)
nSecondGrade = -1 ;
else if ( vTria[1].GetAttrib(0) == 1 || vTria[1].GetAttrib(1) == 1 || vTria[1].GetAttrib(2) == 1)
nSecondGrade = 1 ;
vTria[1].SetGrade( nSecondGrade) ;
vTria[1].Validate( true) ;
}
else if ( vTria[0].GetAttrib(nFst1) == vTria[0].GetAttrib(nFst2) &&
vTria[0].GetAttrib(nFst3) != vTria[1].GetAttrib(nSec3)) {
int nFirstGrade = 0 ;
if ( vTria[0].GetAttrib(0) == -1 || vTria[0].GetAttrib(1) == -1 || vTria[0].GetAttrib(2) == -1)
nFirstGrade = -1 ;
else if ( vTria[0].GetAttrib(0) == 1 || vTria[0].GetAttrib(1) == 1 || vTria[0].GetAttrib(2) == 1)
nFirstGrade = 1 ;
vTria[0].SetGrade( nFirstGrade) ;
int nSecondGrade = 0 ;
if ( vTria[1].GetAttrib(0) == -1 || vTria[1].GetAttrib(1) == -1 || vTria[1].GetAttrib(2) == -1)
nSecondGrade = -1 ;
else if ( vTria[1].GetAttrib(0) == 1 || vTria[1].GetAttrib(1) == 1 || vTria[1].GetAttrib(2) == 1)
nSecondGrade = 1 ;
vTria[1].SetGrade( nSecondGrade) ;
}
}
for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT)
for ( int nT = 0 ; nT < int( vTria.size()) ; ++nT)
VoxSmoothTria.vTria.emplace_back( vTria[nT]) ;
return true ;
return true ;
}
//----------------------------------------------------------------------------