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

EgtGeomKernel 1.8b2 :

Browse Source 
- corretta creazione piramide (verso della base)
- corretta classificazione curve rispetto a regioni con estremi molto vicini alla curva.
This commit is contained in:
Dario Sassi
2017-02-13 16:08:54 +00:00
parent 3987a00eb8
commit 1f6a7b390a
4 changed files with 270 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolTriZmapCreation.cpp
+258 -116
View File
@@ -164,7 +164,6 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
bool
VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bFlag)
{
#if 0
Point3d ptMapOrig, ptMapEnd ;
// Aggiorno la dimensione della mappa 1 o 3
@@ -183,30 +182,31 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
// Sistema di riferimento mappa
m_MapFrame[0].Set( ptMapOrig, X_AX, Y_AX, Z_AX) ;
// Determino le dimensioni lineari X Y della griglia
double dLengthX = ptMapEnd.x - ptMapOrig.x ;
double dLengthY = ptMapEnd.y - ptMapOrig.y ;
// A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe
// della griglia Zmap e da questi la dimensione del vettore di dexel
m_nVNx[0] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nVNy[0] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
//m_nNx[0] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
//m_nNy[0] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nNx[0] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[0] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nVDim[0] = m_nVNx[0] * m_nVNy[0] ;
m_nDim[0] = m_nNx[0] * m_nNy[0] ;
// Ridimensiono il vettore di dexel e creo lo Zmap
m_TriZValues[0].resize( m_nVDim[0]) ;
m_Values[0].resize( m_nDim[0]) ;
// Definisco il numero di blocchi lungo x e y
unsigned int nMinBlockNum = 1 ;
m_nFracLin[0] = max( nMinBlockNum,
m_nVNx[0] / m_nDexNumPBlock +
( m_nVNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNx[0] / m_nDexNumPBlock +
( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nFracLin[1] = max( nMinBlockNum,
m_nVNy[0] / m_nDexNumPBlock +
( m_nVNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNy[0] / m_nDexNumPBlock +
( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
// Se Tridexel ridimensiono anche gli altri vettori
if ( bFlag) {
@@ -214,51 +214,57 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
m_MapFrame[1].Set( ptMapOrig, Y_AX, Z_AX, X_AX) ;
m_MapFrame[2].Set( ptMapOrig, Z_AX, X_AX, Y_AX) ;
m_nVNx[1] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nVNy[1] = static_cast <unsigned int> ( ceil( dDimZ / m_dStep)) ;
//m_nNx[1] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
//m_nNy[1] = static_cast <unsigned int> ( ceil( dDimZ / m_dStep)) ;
m_nVDim[1] = m_nVNx[1] * m_nVNy[1] ;
//m_nNx[2] = static_cast <unsigned int> ( ceil( dDimZ / m_dStep)) ;
//m_nNy[2] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nVNx[2] = static_cast <unsigned int> ( ceil( dDimZ / m_dStep)) ;
m_nVNy[2] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nNx[1] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[1] = static_cast <unsigned int> ( floor( ( dDimZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nVDim[2] = m_nVNx[2] * m_nVNy[2] ;
m_nNx[2] = static_cast <unsigned int> ( floor( ( dDimZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[2] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_TriZValues[1].resize( m_nVDim[1]) ;
m_TriZValues[2].resize( m_nVDim[2]) ;
m_nDim[1] = m_nNx[1] * m_nNy[1] ;
m_nDim[2] = m_nNx[2] * m_nNy[2] ;
m_Values[1].resize( m_nDim[1]) ;
m_Values[2].resize( m_nDim[2]) ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = max( nMinBlockNum,
m_nVNy[1] / m_nDexNumPBlock +
( m_nVNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNy[1] / m_nDexNumPBlock +
( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
}
else {
m_MapFrame[1].Set( ptMapOrig, Y_AX, Z_AX, X_AX) ;
m_MapFrame[2].Set( ptMapOrig, Z_AX, X_AX, Y_AX) ;
m_nVNx[1] = 0 ;
m_nVNy[1] = 0 ;
m_nNx[1] = 0 ;
m_nNy[1] = 0 ;
m_nVDim[1] = 0 ;
m_nDim[1] = 0 ;
m_nVNx[2] = 0 ;
m_nVNy[2] = 0 ;
m_nNx[2] = 0 ;
m_nNy[2] = 0 ;
m_nVDim[2] = 0 ;
m_nDim[2] = 0 ;
}
// Determinazione e ridimensionamento dei dexel
// interni alla regione
// Griglia 0
for ( unsigned int i = 0 ; i < m_nVNx[0] ; ++ i) {
for ( unsigned int i = 0 ; i < m_nNx[0] ; ++ i) {
// Definisco la retta da intersecare con la regione
double dX = ( i + 0.5) * m_dStep ;
Point3d ptP0 = ptMapOrig + Vector3d( dX, 0, 0) ;
Point3d ptP0 = ptMapOrig + Vector3d( dX, 0, 0) ; // CAMBIATO CON EPS
CurveLine GridLine ;
GridLine.SetPVL( ptP0, Y_AX, dLengthY) ;
GridLine.SetPVL( ptP0, Y_AX, dLengthY) ; // CAMBIATO CON EPS
// Determino le intersezioni della retta con la regione
CRVCVECTOR IntersectionResults ;
@@ -280,34 +286,78 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
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 + 0.5)), 0, m_nVNy[0] - 1) ;
int nEndJ = Clamp( int( floor( dt2 * dLengthY / m_dStep - 0.5)), 0, m_nVNy[0] - 1) ;
int nStartJ = Clamp( int( floor( dt1 * dLengthY / m_dStep + 0.5)), 0, m_nNy[0] - 1) ; // CAMBIATO CON EPS
int nEndJ = Clamp( int( floor( dt2 * dLengthY / m_dStep - 0.5)), 0, m_nNy[0] - 1) ; // CAMBIATO CON EPS
// Ridimensiono e riempio i dexel
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
// Determino il dexel
int nPos0 = j * m_nVNx[0] + i ;
int nPos0 = j * m_nNx[0] + i ;
m_TriZValues[0][nPos0].resize( 2) ;
m_Values[0][nPos0].resize( 2) ;
// Aggiorno le quote estreme del segmento
m_TriZValues[0][nPos0][0] = 0 ;
m_TriZValues[0][nPos0][1] = dDimZ ;
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 ;
}
// Se tridexel riempio i singoli dexel della
// griglia 2 con gli intervalli
if ( bFlag) {
for ( size_t a = 0 ; a < m_nVNx[2] ; ++ a) {
for ( size_t a = 0 ; a < m_nNx[2] ; ++ a) {
size_t nPos2 = i * m_nVNx[2] + a ;
size_t nPos2 = i * m_nNx[2] + a ;
size_t nCurrentSize = m_TriZValues[2][nPos2].size( ) ;
size_t nCurrentSize = m_Values[2][nPos2].size( ) ;
m_TriZValues[2][nPos2].resize( nCurrentSize + 2) ;
m_Values[2][nPos2].resize( nCurrentSize + 2) ;
m_TriZValues[2][nPos2][nCurrentSize] = dt1 * dLengthY ;
m_TriZValues[2][nPos2][nCurrentSize + 1] = dt2 * dLengthY ;
m_Values[2][nPos2][nCurrentSize].dZVal = dt1 * dLengthY ;
m_Values[2][nPos2][nCurrentSize + 1].dZVal = dt2 * dLengthY ;
Point3d ptP1 = ptP0 + dt1 * dLengthY * Y_AX ;//+ ( a + 0.5) * Z_AX ; // CAMBIATO CON EPS
Point3d ptP2 = ptP0 + dt2 * dLengthY * Y_AX ;//+ ( a + 0.5) * Z_AX ; // CAMBIATO CON EPS
int nChunkNum = Surf.GetChunkCount() ;
for ( int nChunk = 0 ; nChunk < nChunkNum ; ++ nChunk) {
int nLoopNum = Surf.GetLoopCount( nChunk) ;
for ( int nLoop = 0 ; nLoop < nLoopNum ; ++ nLoop) {
ICurve * pCurve = Surf.GetLoop( nChunk, nLoop) ;
if ( pCurve -> IsPointOn( ptP1)) {
double dP1 ;
Vector3d vtT1, vtN1 ;
pCurve -> GetParamAtPoint(ptP1, dP1) ;
pCurve -> GetPointTang( dP1, ICurve::FROM_MINUS, ptP1, vtT1) ;
vtN1 = vtT1 ^ Z_AX ;
m_Values[2][nPos2][nCurrentSize].vtN = vtN1 ;
}
if ( pCurve -> IsPointOn( ptP2)) {
double dP2 ;
Vector3d vtT2, vtN2 ;
pCurve -> GetParamAtPoint(ptP2, dP2) ;
pCurve -> GetPointTang( dP2, ICurve::FROM_MINUS, ptP1, vtT2) ;
vtN2 = vtT2 ^ Z_AX ;
m_Values[2][nPos2][nCurrentSize+1].vtN = vtN2 ;
}
}
}
}
}
}
@@ -317,13 +367,13 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
// Se tridexel resta la griglia 1
if ( bFlag) {
for ( unsigned int i = 0 ; i < m_nVNx[1] ; ++ i) {
for ( unsigned int i = 0 ; i < m_nNx[1] ; ++ i) {
// Definisco la retta da intersecare con la regione
double dX = ( i + 0.5) * m_dStep ;
Point3d ptP0 = ptMapOrig + Vector3d( 0, dX, 0) ;
Point3d ptP0 = ptMapOrig + Vector3d( 0, dX, 0) ; ////// // CAMBIATO CON EPS
CurveLine GridLine ;
GridLine.SetPVL( ptP0, X_AX, dLengthX) ;
GridLine.SetPVL( ptP0, X_AX, dLengthX ) ; //// // CAMBIATO CON EPS
// Determino le intersezioni della retta con la regione
CRVCVECTOR IntersectionResults ;
@@ -344,16 +394,58 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
double dt1 = IntersectionResults[k].dParS ;
double dt2 = IntersectionResults[k].dParE ;
for ( size_t j = 0 ; j < m_nVNy[1] ; ++ j) {
for ( size_t j = 0 ; j < m_nNy[1] ; ++ j) {
size_t nPos1 = j * m_nVNx[1] + i ;
size_t nPos1 = j * m_nNx[1] + i ;
size_t nCurrentSize = m_TriZValues[1][nPos1].size( ) ;
size_t nCurrentSize = m_Values[1][nPos1].size( ) ;
m_TriZValues[1][nPos1].resize( nCurrentSize + 2) ;
m_Values[1][nPos1].resize( nCurrentSize + 2) ;
m_TriZValues[1][nPos1][nCurrentSize] = dt1 * dLengthX ;
m_TriZValues[1][nPos1][nCurrentSize + 1] = dt2 * dLengthX ;
m_Values[1][nPos1][nCurrentSize].dZVal = dt1 * dLengthX ; // CAMBIATO CON EPS
m_Values[1][nPos1][nCurrentSize + 1].dZVal = dt2 * dLengthX ; // CAMBIATO CON EPS
Point3d ptP1 = ptP0 + dt1 * dLengthX * X_AX ; /// cAMBIO
Point3d ptP2 = ptP0 + dt2 * dLengthX * X_AX ; // CAMBIATO CON EPS
int nChunkNum = Surf.GetChunkCount() ;
for ( int nChunk = 0 ; nChunk < nChunkNum ; ++ nChunk) {
int nLoopNum = Surf.GetLoopCount( nChunk) ;
for ( int nLoop = 0 ; nLoop < nLoopNum ; ++ nLoop) {
ICurve * pCurve = Surf.GetLoop( nChunk, nLoop) ;
if ( pCurve -> IsPointOn( ptP1)) {
double dP1 ;
Vector3d vtT1, vtN1 ;
pCurve -> GetParamAtPoint(ptP1, dP1) ;
pCurve -> GetPointTang( dP1, ICurve::FROM_MINUS, ptP1, vtT1) ;
vtN1 = vtT1 ^ Z_AX ;
m_Values[1][nPos1][nCurrentSize].vtN = vtN1 ;
}
if ( pCurve -> IsPointOn( ptP2)) {
double dP2 ;
Vector3d vtT2, vtN2 ;
pCurve -> GetParamAtPoint(ptP2, dP2) ;
pCurve -> GetPointTang( dP2, ICurve::FROM_MINUS, ptP1, vtT2) ;
vtN2 = vtT2 ^ Z_AX ;
m_Values[1][nPos1][nCurrentSize+1].vtN = vtN2 ;
}
}
}
}
}
}
@@ -361,22 +453,22 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
}
m_dVMinZ[0] = 0 ;
m_dVMaxZ[0] = dDimZ ;
m_dMinZ[0] = 0 ;
m_dMaxZ[0] = dDimZ ;
if ( bFlag) {
m_dVMinZ[1] = 0 ;
m_dVMaxZ[1] = dLengthX ;
m_dVMinZ[2] = 0 ;
m_dVMaxZ[2] = dLengthY ;
m_dMinZ[1] = 0 ;
m_dMaxZ[1] = dLengthX ;
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = dLengthY ;
}
else {
m_dVMinZ[1] = 0 ;
m_dVMaxZ[1] = 0 ;
m_dVMinZ[2] = 0 ;
m_dVMaxZ[2] = 0 ;
m_dMinZ[1] = 0 ;
m_dMaxZ[1] = 0 ;
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = 0 ;
}
// Ridimensiono e setto il vettore dei blocchi a falso
@@ -390,15 +482,14 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
// Aggiornamento dello stato
m_nStatus = OK ;
#endif
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
{
#if 0
{
// Se la superficie non è chiusa non ha senso continuare
if ( ! Surf.IsClosed())
return false ;
@@ -428,23 +519,23 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
// A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe
// della griglia Zmap e da questi la dimensione del vettore di dexel
m_nVNx[0] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nVNy[0] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nNx[0] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[0] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nVDim[0] = m_nVNx[0] * m_nVNy[0] ;
m_nDim[0] = m_nNx[0] * m_nNy[0] ;
// Ridimensiono il vettore di dexel e creo lo Zmap
m_TriZValues[0].resize( m_nVDim[0]) ;
m_Values[0].resize( m_nDim[0]) ;
// Definisco il numero di blocchi lungo x e y
unsigned int nMinBlockNum = 1 ;
m_nFracLin[0] = max( nMinBlockNum,
m_nVNx[0] / m_nDexNumPBlock +
( m_nVNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNx[0] / m_nDexNumPBlock +
( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nFracLin[1] = max( nMinBlockNum,
m_nVNy[0] / m_nDexNumPBlock +
( m_nVNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNy[0] / m_nDexNumPBlock +
( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
// Se Tridexel ridimensiono anche gli altri vettori
if ( bFlag) {
@@ -452,23 +543,23 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
m_MapFrame[1].Set( ptMapOrig, Y_AX, Z_AX, X_AX) ; // Sarà Front Left
m_MapFrame[2].Set( ptMapOrig, Z_AX, X_AX, Y_AX) ;
m_nVNx[1] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nVNy[1] = static_cast <unsigned int> ( ceil( dLengthZ / m_dStep)) ;
m_nNx[1] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[1] = static_cast <unsigned int> ( floor( ( dLengthZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nVDim[1] = m_nVNx[1] * m_nVNy[1] ;
m_nDim[1] = m_nNx[1] * m_nNy[1] ;
m_nVNx[2] = static_cast <unsigned int> ( ceil( dLengthZ / m_dStep)) ;
m_nVNy[2] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nNx[2] = static_cast <unsigned int> ( floor( ( dLengthZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nNy[2] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
m_nVDim[2] = m_nVNx[2] * m_nVNy[2] ;
m_nDim[2] = m_nNx[2] * m_nNy[2] ;
m_TriZValues[1].resize( m_nVDim[1]) ;
m_TriZValues[2].resize( m_nVDim[2]) ;
m_Values[1].resize( m_nDim[1]) ;
m_Values[2].resize( m_nDim[2]) ;
// Definisco il numero di blocchi lungo z
m_nFracLin[2] = max( nMinBlockNum,
m_nVNy[1] / m_nDexNumPBlock +
( m_nVNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
m_nNy[1] / m_nDexNumPBlock +
( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
}
@@ -476,8 +567,8 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
IntersParLinesSurfTm intPLSTM( m_MapFrame[0], Surf) ;
// Determinazione e ridimensionamento dei dexel interni alla trimesh
for ( unsigned int i = 0 ; i < m_nVNx[0] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nVNy[0] ; ++ j) {
for ( unsigned int i = 0 ; i < m_nNx[0] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nNy[0] ; ++ j) {
// Definisco la retta da intersecare con la trimesh
double dX = ( i + 0.5) * m_dStep ;
@@ -490,10 +581,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
int nInt = int( IntersectionResults.size()) ;
unsigned int nPos = j * m_nVNx[0] + i ;
unsigned int nPos = j * m_nNx[0] + i ;
bool bInside = false ;
Point3d ptIn ;
Vector3d vtInN ;
for ( int k = 0 ; k < nInt ; ++ k) {
int nIntType = IntersectionResults[k].nILTT ;
@@ -508,6 +601,11 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
ptIn = IntersectionResults[k].ptI ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtInN) ;
bInside = true ;
}
@@ -516,12 +614,22 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
Point3d ptOut = IntersectionResults[k].ptI ;
unsigned int nCurrentSize = unsigned int( m_TriZValues[0][nPos].size()) ;
m_TriZValues[0][nPos].resize( nCurrentSize + 2) ;
Vector3d vtOutN ;
m_TriZValues[0][nPos][nCurrentSize] = ptIn.z - ptMapOrig.z ;
m_TriZValues[0][nPos][nCurrentSize + 1] = ptOut.z - ptMapOrig.z ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtOutN) ;
unsigned int nCurrentSize = unsigned int( m_Values[0][nPos].size()) ;
m_Values[0][nPos].resize( nCurrentSize + 2) ;
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 ;
bInside = false ;
}
@@ -535,8 +643,8 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
IntersParLinesSurfTm intPLSTM1( m_MapFrame[1], Surf) ;
// Determinazione e ridimensionamento dei dexel interni alla trimesh
for ( unsigned int i = 0 ; i < m_nVNx[1] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nVNy[1] ; ++ j) {
for ( unsigned int i = 0 ; i < m_nNx[1] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nNy[1] ; ++ j) {
// Definisco la retta da intersecare con la trimesh
double dX = ( i + 0.5) * m_dStep ;
@@ -549,10 +657,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
int nInt = int( IntersectionResults.size()) ;
unsigned int nPos = j * m_nVNx[1] + i ;
unsigned int nPos = j * m_nNx[1] + i ;
bool bInside = false ;
Point3d ptIn ;
Vector3d vtInN ;
for ( int k = 0 ; k < nInt ; ++ k) {
int nIntType = IntersectionResults[k].nILTT ;
@@ -567,6 +677,11 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
ptIn = IntersectionResults[k].ptI ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtInN) ;
bInside = true ;
}
@@ -575,13 +690,23 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
Point3d ptOut = IntersectionResults[k].ptI ;
unsigned int nCurrentSize = unsigned int( m_TriZValues[1][nPos].size()) ;
Vector3d vtOutN ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtOutN) ;
unsigned int nCurrentSize = unsigned int( m_Values[1][nPos].size()) ;
m_TriZValues[1][nPos].resize( nCurrentSize + 2) ;
m_Values[1][nPos].resize( nCurrentSize + 2) ;
m_TriZValues[1][nPos][nCurrentSize] = ptIn.x - ptMapOrig.x ;
m_TriZValues[1][nPos][nCurrentSize + 1] = ptOut.x - ptMapOrig.x ;
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 ;
bInside = false ;
}
}
@@ -592,8 +717,8 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
IntersParLinesSurfTm intPLSTM2( m_MapFrame[2], Surf) ;
// Determinazione e ridimensionamento dei dexel interni alla trimesh
for ( unsigned int i = 0 ; i < m_nVNx[2] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nVNy[2] ; ++ j) {
for ( unsigned int i = 0 ; i < m_nNx[2] ; ++ i) {
for ( unsigned int j = 0 ; j < m_nNy[2] ; ++ j) {
// Definisco la retta da intersecare con la trimesh
double dX = ( i + 0.5) * m_dStep ;
@@ -606,10 +731,12 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
int nInt = int( IntersectionResults.size()) ;
unsigned int nPos = j * m_nVNx[2] + i ;
unsigned int nPos = j * m_nNx[2] + i ;
bool bInside = false ;
Point3d ptIn ;
Vector3d vtInN ;
for ( int k = 0 ; k < nInt ; ++ k) {
int nIntType = IntersectionResults[k].nILTT ;
@@ -624,6 +751,11 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
ptIn = IntersectionResults[k].ptI ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtInN) ;
bInside = true ;
}
@@ -632,12 +764,22 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
Point3d ptOut = IntersectionResults[k].ptI ;
unsigned int nCurrentSize = unsigned int( m_TriZValues[2][nPos].size()) ;
m_TriZValues[2][nPos].resize( nCurrentSize + 2) ;
Vector3d vtOutN ;
m_TriZValues[2][nPos][nCurrentSize] = ptIn.y - ptMapOrig.y ;
m_TriZValues[2][nPos][nCurrentSize + 1] = ptOut.y - ptMapOrig.y ;
int nT = IntersectionResults[k].nT ;
int nF = Surf.GetFacetFromTria( nT) ;
Surf.GetFacetNormal( nF, vtOutN) ;
unsigned int nCurrentSize = unsigned int( m_Values[2][nPos].size()) ;
m_Values[2][nPos].resize( nCurrentSize + 2) ;
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 ;
bInside = false ;
}
@@ -648,22 +790,22 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
}
// Assegno il minimo e massimo valore di Z della mappa
m_dVMinZ[0] = 0 ;
m_dVMaxZ[0] = dLengthZ ;
m_dMinZ[0] = 0 ;
m_dMaxZ[0] = dLengthZ ;
if ( bFlag) {
m_dVMinZ[1] = 0 ;
m_dVMaxZ[1] = dLengthX ;
m_dVMinZ[2] = 0 ;
m_dVMaxZ[2] = dLengthY ;
m_dMinZ[1] = 0 ;
m_dMaxZ[1] = dLengthX ;
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = dLengthY ;
}
else {
m_dVMinZ[1] = 0 ;
m_dVMaxZ[1] = 0 ;
m_dVMinZ[2] = 0 ;
m_dVMaxZ[2] = 0 ;
m_dMinZ[1] = 0 ;
m_dMaxZ[1] = 0 ;
m_dMinZ[2] = 0 ;
m_dMaxZ[2] = 0 ;
}
// Ridimensiono e setto il vettore dei blocchi a falso
@@ -675,7 +817,7 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
m_BlockToUpdate[nCount] = true ;
m_nStatus = OK ;
#endif
m_nStatus = OK ;
return true ;
}