//----------------------------------------------------------------------------
//  EgalTech 2015-2016
//----------------------------------------------------------------------------
// File : VolZmap.cpp         Data : 22.01.15           Versione : 1.6a4
// Contenuto : Implementazione della classe Volume Zmap (singola griglia)
//
//
//
// Modifiche : 22.01.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "VolZmap.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "NgeReader.h"
#include "GeoConst.h"
#include "\EgtDev\Include\EGkIntervals.h"


using namespace std ;

//----------------------------------------------------------------------------
GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;

//----------------------------------------------------------------------------
VolZmap::VolZmap(void)
   : m_nStatus( TO_VERIFY), m_nTempProp(), m_dLinTol( LIN_TOL_STD), m_dAngTolDeg( ANG_TOL_APPROX_DEG)
{
   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<const VolZmap*>( 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<GeoObjType>( 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() ;
  // se richiesto approssimato
   if ( ( nFlag & BBF_EXACT) == 0) {
      b3Loc.Add( ORIG) ;
      b3Loc.Add( Point3d( m_nNx * m_dStep, m_nNy * m_dStep, m_dMaxZ)) ;
      b3Loc.ToGlob( m_LocalFrame) ;
      return true ;
   }
  // calcolo preciso
   // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
   double dY = 0 ;
   for ( size_t j = 0 ; j <= m_nNy ; ++ j) {
      size_t jc = ( ( j != m_nNy) ? j : m_nNy -1) ;
      double dX = 0 ;
     // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
      for ( size_t i = 0 ; i <= m_nNx ; ++ i) {
         size_t ic = ( ( i != m_nNx) ? i : m_nNx -1) ;
         size_t nPos = ic + jc * 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()) ;
         }
        // passo al punto successivo
         dX += m_dStep ;
      }
     // passo alla riga successiva
      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) ;
  // se richiesto approssimato
   if ( ( nFlag & BBF_EXACT) == 0) {
      b3Ref.Add( ORIG) ;
      b3Ref.Add( Point3d( m_nNx * m_dStep, m_nNy * m_dStep, m_dMaxZ)) ;
      b3Ref.ToGlob( frUse) ;
      return true ;
   }
  // calcolo preciso
   // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
   double dY = 0 ;
   for ( size_t j = 0 ; j <= m_nNy ; ++ j) {
      size_t jc = ( ( j != m_nNy) ? j : m_nNy -1) ;
      double dX = 0 ;
     // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
      for ( size_t i = 0 ; i <= m_nNx ; ++ i) {
         size_t ic = ( ( i != m_nNx) ? i : m_nNx -1) ;
         size_t nPos = ic + jc * 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()) ;
         }
        // passo al punto successivo
         dX += m_dStep ;
      }
     // passo alla riga successiva
      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 ;
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo il riferimento
   return m_LocalFrame.ToGlob( frRef) ;
}

//----------------------------------------------------------------------------
bool 
VolZmap::ToLoc( const Frame3d& frRef)
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo il riferimento
   return m_LocalFrame.ToLoc( frRef) ;
}

//----------------------------------------------------------------------------
bool 
VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo il riferimento
   return m_LocalFrame.LocToLoc( frOri, frDest) ;
}