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

EgtGeomKernel 1.8f1 :

Browse Source 
- modifiche a Zmap per salvataggio/lettura e altro con nuova struttura a blocchi.
This commit is contained in:
Dario Sassi
2017-06-05 07:20:45 +00:00
parent 98299d118c
commit 17425bc753
8 changed files with 861 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolTriZmapGraphics.cpp
+88 -97
View File
@@ -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 ;
}
}