//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : GeoFrame3d.cpp      Data : 02.12.13          Versione : 1.4a3
// Contenuto : Implementazione della classe Riferimento geometrico.
//
//
//
// Modifiche : 10.10.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "GeoFrame3d.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "NgeReader.h"
#include "/EgtDev/Include/EGkPolyLine.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUiUnits.h"
#include <new>

using namespace std ;

//----------------------------------------------------------------------------
GEOOBJ_REGISTER( GEO_FRAME3D, NGE_G_FRM, GeoFrame3d) ;

//----------------------------------------------------------------------------
GeoFrame3d::GeoFrame3d( void)
   : m_frF(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}
{
}

//----------------------------------------------------------------------------
GeoFrame3d::~GeoFrame3d( void)
{
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirX, 
                 const Vector3d& vtDirY, const Vector3d& vtDirZ)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // assegno i dati
   return m_frF.Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Set( const Point3d& ptOrig, const Point3d& ptOnX, const Point3d& ptNearY)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // assegno i dati
   return m_frF.Set( ptOrig, ptOnX, ptNearY) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirZ)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // assegno i dati
   return m_frF.Set( ptOrig, vtDirZ) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Set( const Frame3d& frF)
{
   if ( ! frF.IsValid())
      return false ;
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // assegno i dati
   m_frF = frF ;
   return true ;
}

//----------------------------------------------------------------------------
GeoFrame3d*
GeoFrame3d::Clone( void) const
{
  // alloco oggetto
   GeoFrame3d* pGFr = new( nothrow) GeoFrame3d ;
   if ( pGFr != nullptr) {
      if ( ! pGFr->CopyFrom( *this)) {
         delete pGFr ;
         return nullptr ;
      }
   }

   return pGFr ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::CopyFrom( const IGeoObj* pGObjSrc)
{
   const GeoFrame3d* pGFr = GetBasicGeoFrame3d( pGObjSrc) ;
   if ( pGFr == nullptr)
      return false ;
   return CopyFrom( *pGFr) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::CopyFrom( const GeoFrame3d& gfSrc)
{
   if ( &gfSrc == this)
      return true ;
   m_nTempProp[0] = gfSrc.m_nTempProp[0] ;
   m_nTempProp[1] = gfSrc.m_nTempProp[1] ;
   m_dTempParam[0] = gfSrc.m_dTempParam[0] ;
   m_dTempParam[1] = gfSrc.m_dTempParam[1] ;
   return Set( gfSrc.m_frF) ;
}

//----------------------------------------------------------------------------
GeoObjType
GeoFrame3d::GetType( void) const
{
   return static_cast<GeoObjType>( GEOOBJ_GETTYPE( GeoFrame3d)) ;
}

//----------------------------------------------------------------------------
const string&
GeoFrame3d::GetTitle( void) const
{
   static const string sTitle = "Frame" ;
   return sTitle ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Dump( string& sOut, bool bMM, const char* szNewLine) const
{
  // parametri : origine, VersoreX, VersoreY, VersoreZ
   sOut += "O(" + ToString( GetInUiUnits( m_frF.Orig(), bMM)) + ")" + szNewLine ;
   sOut += "VX(" + ToString( m_frF.VersX()) + ")" + szNewLine ;
   sOut += "VY(" + ToString( m_frF.VersY()) + ")" + szNewLine ;
   sOut += "VZ(" + ToString( m_frF.VersZ()) + ")" + szNewLine ;

   return true ;
}

//----------------------------------------------------------------------------
int
GeoFrame3d::GetNgeId( void) const
{
   return GEOOBJ_GETNGEID( GeoFrame3d) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Save( NgeWriter& ngeOut) const
{
   return ngeOut.WriteFrame( m_frF, ";", true) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::Load( NgeReader& ngeIn)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // leggo la prossima linea
   return ngeIn.ReadFrame( m_frF, ";", true) ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
{
  // assegno il box in locale (considero l'origine)
   b3Loc.Set( m_frF.Orig()) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
{
  // verifico validità del frame
   if ( frRef.GetType() == Frame3d::ERR)
      return false ;
  // porto l'origine nel riferimento passato
   Point3d ptP = m_frF.Orig() ;
   ptP.ToGlob( frRef) ;
  // assegno il box nel riferimento
   b3Ref.Set( ptP) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
GeoFrame3d::GetDrawWithArrowHeads( double dLenA, double dFrazLenAH,
                                   PolyLine& plX, PolyLine& plY, PolyLine& plZ) const
{
   const double A_WIDTH_COEFF = 0.258819 ;
   double dLenAH = dFrazLenAH * dLenA ;
  // vettore X (con freccia)
   plX.AddUPoint( 0, m_frF.Orig()) ;
   Point3d ptTipX = m_frF.Orig() + m_frF.VersX() * dLenA ;
   plX.AddUPoint( 1, ptTipX) ;
   Point3d ptP1X = ptTipX + ( - m_frF.VersX() - A_WIDTH_COEFF * m_frF.VersY()) * dLenAH ;
   plX.AddUPoint( 2, ptP1X) ;
   Point3d ptP2X = ptTipX + ( - m_frF.VersX() + A_WIDTH_COEFF * m_frF.VersY()) * dLenAH ;
   plX.AddUPoint( 3, ptP2X) ;
   plX.AddUPoint( 4, ptTipX) ;
  // vettore Y (con freccia)
   plY.AddUPoint( 0, m_frF.Orig()) ;
   Point3d ptTipY = m_frF.Orig() + m_frF.VersY() * dLenA ;
   plY.AddUPoint( 1, ptTipY) ;
   Point3d ptP1Y = ptTipY + ( - m_frF.VersY() - A_WIDTH_COEFF * m_frF.VersX()) * dLenAH ;
   plY.AddUPoint( 2, ptP1Y) ;
   Point3d ptP2Y = ptTipY + ( - m_frF.VersY() + A_WIDTH_COEFF * m_frF.VersX()) * dLenAH ;
   plY.AddUPoint( 3, ptP2Y) ;
   plY.AddUPoint( 4, ptTipY) ;
  // vettore Z (con doppia freccia)
   plZ.AddUPoint( 0, m_frF.Orig()) ;
   Point3d ptTipZ = m_frF.Orig() + m_frF.VersZ() * dLenA ;
   plZ.AddUPoint( 1, ptTipZ) ;
   Point3d ptP1Z = ptTipZ + ( - m_frF.VersZ() - A_WIDTH_COEFF * m_frF.VersX()) * dLenAH ;
   plZ.AddUPoint( 2, ptP1Z) ;
   Point3d ptP2Z = ptTipZ + ( - m_frF.VersZ() + A_WIDTH_COEFF * m_frF.VersX()) * dLenAH ;
   plZ.AddUPoint( 3, ptP2Z) ;
   plZ.AddUPoint( 4, ptTipZ) ;
   Point3d ptP3Z = ptTipZ + ( - m_frF.VersZ() - A_WIDTH_COEFF * m_frF.VersY()) * dLenAH ;
   plZ.AddUPoint( 5, ptP3Z) ;
   Point3d ptP4Z = ptTipZ + ( - m_frF.VersZ() + A_WIDTH_COEFF * m_frF.VersY()) * dLenAH ;
   plZ.AddUPoint( 6, ptP4Z) ;
   plZ.AddUPoint( 7, ptTipZ) ;

   return true ;
}