//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : VolZmap.cpp Data : 22.01.15 Versione : 1.6a4 // Contenuto : Implementazione della classe Volume Zmap. // // // // Modifiche : 22.01.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "VolZmap.h" #include "GeoObjFactory.h" #include "NgeWriter.h" #include "NgeReader.h" using namespace std ; //---------------------------------------------------------------------------- GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ; //---------------------------------------------------------------------------- VolZmap::VolZmap(void) : m_nStatus( TO_VERIFY), m_nTempProp() { m_dStep = 0 ; m_nNx = 0 ; m_nNy = 0 ; m_nDim = 0 ; } //---------------------------------------------------------------------------- VolZmap::~VolZmap( void) { } //---------------------------------------------------------------------------- VolZmap* VolZmap::Clone( void) const { // alloco oggetto VolZmap* pVzm = new(nothrow) VolZmap ; if ( pVzm != nullptr) { if ( ! pVzm->CopyFrom( *this)) { delete pVzm ; return nullptr ; } } return pVzm ; } //---------------------------------------------------------------------------- bool VolZmap::CopyFrom( const IGeoObj* pGObjSrc) { const VolZmap* pVzm = dynamic_cast( pGObjSrc) ; if ( pVzm == nullptr) return false ; return CopyFrom( *pVzm) ; } //---------------------------------------------------------------------------- bool VolZmap::CopyFrom( const VolZmap& vzmSrc) { if ( &vzmSrc == this) return true ; m_OGrMgr.Reset() ; m_LocalFrame = vzmSrc.m_LocalFrame ; m_dStep = vzmSrc.m_dStep ; m_nDim = vzmSrc.m_nDim ; m_nNx = vzmSrc.m_nNx ; m_nNy = vzmSrc.m_nNy ; m_ZValues = vzmSrc.m_ZValues ; m_nStatus = vzmSrc.m_nStatus ; m_nTempProp = vzmSrc.m_nTempProp ; return true ; } //---------------------------------------------------------------------------- GeoObjType VolZmap::GetType( void) const { return static_cast( GEOOBJ_GETTYPE( VolZmap)) ; } //---------------------------------------------------------------------------- const string& VolZmap::GetTitle( void) const { static const string sTitle = "Zmap" ; return sTitle ; } //---------------------------------------------------------------------------- bool VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const { return false ; } //---------------------------------------------------------------------------- int VolZmap::GetNgeId( void) const { return GEOOBJ_GETNGEID( VolZmap) ; } //---------------------------------------------------------------------------- bool VolZmap::Save( NgeWriter& ngeOut) const { // parametri di scrittura: sistema di riferimento, minimo incremento, numero di passi // in direzione x e y, e per ogni casella, numero di valori e valori if ( ! ngeOut.WriteFrame( m_LocalFrame, ";", true)) return false ; if ( ! ngeOut.WriteDouble( m_dStep, ",", false)) return false ; if ( ! ngeOut.WriteInt( m_nNx, ",", false)) return false ; if ( ! ngeOut.WriteInt( m_nNy, ";", true)) return false ; // ciclo sui dexel for ( unsigned int i = 0 ; i < m_nDim ; ++ i) { // numero di estremi int nDim = int( m_ZValues[i].size()) ; if ( ! ngeOut.WriteInt( nDim, ",", false)) return false ; // se dexel nullo if ( nDim == 0) { // scrivo un valore dummy if ( ! ngeOut.WriteDouble( 0, ";", true)) return false ; } // altrimenti else { for ( unsigned int k = 0 ; k < m_ZValues[i].size() ; ++ k) { bool bEndL = ( k == m_ZValues[i].size() - 1) ; if ( ! ngeOut.WriteDouble( m_ZValues[i][k], ( bEndL ? ";" : ","), bEndL)) return false ; } } } return true ; } //---------------------------------------------------------------------------- bool VolZmap::Load( NgeReader& ngeIn) { m_nStatus = TO_VERIFY ; // parametri di lettura: sistema di riferimento, minimo incremento, numero di passi // in direzione x e y, e per ogni casella, numero di valori e valori if ( ! ngeIn.ReadFrame( m_LocalFrame, ";", true)) return false ; if ( ! ngeIn.ReadDouble( m_dStep, ",", false)) return false ; int nTemp ; if ( ! ngeIn.ReadInt( nTemp, ",", false)) return false ; m_nNx = nTemp ; if ( ! ngeIn.ReadInt( nTemp, ";", true)) return false ; m_nNy = nTemp ; // dimensione del vettore di dexel m_nDim = m_nNx * m_nNy ; m_ZValues.resize(m_nDim) ; // ciclo sui dexel for ( unsigned int i = 0 ; i < m_nDim ; ++ i) { // leggo il numero di estremi nel dexel if ( ! ngeIn.ReadInt( nTemp, ",", false)) return false ; // devono essere pari if ( ( nTemp % 2) != 0) return false ; // se dexel nullo if ( nTemp == 0) { // leggo un valore dummy double dDummy ; if ( ! ngeIn.ReadDouble( dDummy, ",", true)) return false ; } // altrimenti else { // dimensiono l'array m_ZValues[i].resize(nTemp) ; // leggo i valori for ( unsigned int k = 0 ; k < m_ZValues[i].size() ; ++ k) { bool bEndL = ( k == m_ZValues[i].size() - 1) ; if ( ! ngeIn.ReadDouble( m_ZValues[i][k], ( bEndL ? ";" : ","), bEndL)) return false ; } } } m_nStatus = OK ; return true ; } //---------------------------------------------------------------------------- bool VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const { // verifico lo stato if ( m_nStatus != OK) return false ; // reset box b3Loc.Reset() ; // ciclo sui dexel double dY = 0.5 * m_dStep ; for ( size_t i = 0 ; i < m_nNy ; ++ i) { double dX = 0.5 * m_dStep ; for ( size_t j = 0 ; j < m_nNx ; ++ j) { size_t nPos = j + i * m_nNx ; if ( m_ZValues[nPos].size() > 0) { Point3d ptP = m_LocalFrame.Orig() + dX * m_LocalFrame.VersX() + dY * m_LocalFrame.VersY() ; b3Loc.Add( ptP + m_ZValues[nPos][0] * m_LocalFrame.VersZ()) ; b3Loc.Add( ptP + m_ZValues[nPos][m_ZValues[nPos].size()-1] * m_LocalFrame.VersZ()) ; } dX += m_dStep ; } dY += m_dStep ; } return true ; } //---------------------------------------------------------------------------- bool VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const { // verifico lo stato if ( m_nStatus != OK) return false ; // reset box b3Ref.Reset() ; // trasformo il riferimento locale tramite quello passato Frame3d frUse = m_LocalFrame ; frUse.ToGlob( frRef) ; // ciclo sui dexel double dY = 0.5 * m_dStep ; for ( size_t i = 0 ; i < m_nNy ; ++ i) { double dX = 0.5 * m_dStep ; for ( size_t j = 0 ; j < m_nNx ; ++ j) { size_t nPos = j + i * m_nNx ; if ( m_ZValues[nPos].size() > 0) { Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ; b3Ref.Add( ptP + m_ZValues[nPos][0] * frUse.VersZ()) ; b3Ref.Add( ptP + m_ZValues[nPos][m_ZValues[nPos].size()-1] * frUse.VersZ()) ; } dX += m_dStep ; } dY += m_dStep ; } return true ; } //---------------------------------------------------------------------------- bool VolZmap::Translate( const Vector3d& vtMove) { // verifico lo stato if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica m_OGrMgr.Reset() ; // traslo il riferimento m_LocalFrame.Translate( vtMove) ; return true ; } //---------------------------------------------------------------------------- bool VolZmap::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) { // verifico lo stato if ( m_nStatus != OK) return false ; // imposto ricalcolo della grafica m_OGrMgr.Reset() ; // ruoto il riferimento return m_LocalFrame.Rotate( ptAx, vtAx, dCosAng, dSinAng) ; } //---------------------------------------------------------------------------- bool VolZmap::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::ToGlob( const Frame3d& frRef) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::ToLoc( const Frame3d& frRef) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest) { // verifico lo stato if ( m_nStatus != OK) return false ; return false ; } //---------------------------------------------------------------------------- bool VolZmap::CreateMap( const Point3d& ptO, double dPrec, double dLengthX, double dLengthY, double dLengthZ) { // Controlli sui parametri if ( dPrec < EPS_SMALL || dLengthX < EPS_SMALL || dLengthY < EPS_SMALL || dLengthZ < EPS_SMALL) return false ; m_LocalFrame.Set( ptO, X_AX, Y_AX, Z_AX) ; m_dStep = dPrec ; m_nNx = static_cast ( ceil( dLengthX / m_dStep)) ; m_nNy = static_cast ( ceil( dLengthY / m_dStep)) ; m_nDim = m_nNx * m_nNy ; m_ZValues.resize( m_nDim) ; for ( int i = 0 ; i < int( m_nDim) ; i++) { m_ZValues[i].resize(2) ;///? m_ZValues[i][0] = 0 ; m_ZValues[i][1] = dLengthZ ; } m_nStatus = OK ; return true ; } //---------------------------------------------------------------------------- bool VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const { // pulisco la lista lstPL.clear() ; // per ora solo perpendicolari a XY (1) if ( nDir != 1) return false ; // verifiche sugli indici if ( nPos1 < 0 || nPos1 >= int( m_nNx) || nPos2 < 0 || nPos2 >= int( m_nNy)) return false ; int nPos = nPos1 + nPos2 * m_nNx ; if ( nPos < 0 || nPos >= int( m_ZValues.size())) return false ; // calcolo coordinate punto double dX = m_dStep * ( 0.5 + nPos1) ; double dY = m_dStep * ( 0.5 + nPos2) ; Point3d ptP = m_LocalFrame.Orig() + dX * m_LocalFrame.VersX() + dY * m_LocalFrame.VersY() ; // creo le polilinee for ( int i = 1 ; i < int( m_ZValues[nPos].size()) ; i += 2) { // aggiungo polilinea a lista lstPL.emplace_back() ; // inserisco punti estremi lstPL.back().AddUPoint( 0, ptP + m_ZValues[nPos][i-1] * m_LocalFrame.VersZ()) ; lstPL.back().AddUPoint( 1, ptP + m_ZValues[nPos][i] * m_LocalFrame.VersZ()) ; } return true ; }