//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : PolyArc.cpp          Data : 14.08.14          Versione : 1.5h3
// Contenuto : Implementazione della classe PolyArc.
//
//
//
// Modifiche : 14.08.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "\EgtDev\Include\EGkPolyArc.h"


//----------------------------------------------------------------------------
PolyArc::PolyArc( void)
{
   m_vtExtr = Z_AX ;
   m_nRejected = 0 ;
   m_nCount = 0 ;
   m_iter = m_lUPointBs.end() ;
}

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

//----------------------------------------------------------------------------
bool
PolyArc::Clear( void)
{
   m_vtExtr = Z_AX ;
   m_nRejected = 0 ;
   m_nCount = 0 ;
   m_lUPointBs.clear() ;
   m_iter = m_lUPointBs.end() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::SetExtrusion( const Vector3d& vtExtr)
{
   if ( vtExtr.IsSmall())
      return false ;
   m_vtExtr = vtExtr ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::AddUPoint( double dPar, const Point3d& ptP, double dBulge)
{
  // se il punto è uguale al precedente (ignoro parametro e bulge), non lo inserisco ma ok
   if ( m_nCount > 0  &&  AreSamePointApprox( ptP, m_lUPointBs.back().ptP)) {
      ++ m_nRejected ;
      return true ;
   }
   try {
      m_lUPointBs.push_back( UPointB( dPar, ptP, dBulge)) ;
   }
   catch (...) {
      return false ;
   }

   m_nCount ++ ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Close( void)
{
  // ci devono essere almeno 2 punti
   if ( m_lUPointBs.size() < 2)
      return false ;
  // verifico non sia già chiuso
   if ( AreSamePointApprox( m_lUPointBs.front().ptP, m_lUPointBs.back().ptP))
      return false ;
  // aggiungo un punto uguale al primo in coda
   return AddUPoint( m_lUPointBs.front().dU, m_lUPointBs.front().ptP, m_lUPointBs.front().dB) ;
}

//----------------------------------------------------------------------------
bool
PolyArc::ModifyLastBulge( double dBulge)
{
  // verifico esistano dei punti
   if ( m_lUPointBs.empty())
      return false ;
  // eseguo la modifica
   m_lUPointBs.back().dB = dBulge ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::EraseFirstUPoint( void)
{
   if ( m_lUPointBs.empty())
      return false ;

   m_lUPointBs.pop_front() ;
   m_nCount -- ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::EraseLastUPoint( void)
{
   if ( m_lUPointBs.empty())
      return false ;

   m_lUPointBs.pop_back() ;
   m_nCount -- ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::AddOffsetToU( double dOffset)
{
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->dU += dOffset ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::SetElevation( double dZ)
{
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.z = dZ ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::AddElevation( double dZ)
{
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.z += dZ ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Translate( const Vector3d& vtMove)
{
   // il vettore estrusione non subisce modifiche
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.Translate( vtMove) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
   m_vtExtr.Rotate( vtAx, dCosAng, dSinAng) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Scale( const Frame3d& frRef, double dCoeff)
{
   m_vtExtr.Scale( frRef, dCoeff, dCoeff, dCoeff) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.Scale( frRef, dCoeff, dCoeff, dCoeff) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
{
   m_vtExtr.Mirror( vtNorm) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter) {
      iter->ptP.Mirror( ptOn, vtNorm) ;
      iter->dB *= - 1 ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::ToGlob( const Frame3d& frRef)
{
   m_vtExtr.ToGlob( frRef) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::ToLoc( const Frame3d& frRef)
{
   m_vtExtr.ToLoc( frRef) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.ToLoc( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
{
   m_vtExtr.LocToLoc( frOri, frDest) ;
   UPNTBLIST::iterator iter ;
   for ( iter = m_lUPointBs.begin() ; iter != m_lUPointBs.end() ; ++ iter)
      iter->ptP.LocToLoc( frOri, frDest) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::Splice( PolyArc& PA)
{
   m_lUPointBs.splice( m_lUPointBs.end(), PA.m_lUPointBs) ;   
   m_nCount += PA.GetPointNbr() ;
   PA.m_nCount = 0 ;
      
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::GetFirstUPoint( double* pdPar, Point3d* pptP, double* pdBulge, bool bNotLast) const
{
  // cerco il primo punto
   m_iter = m_lUPointBs.begin() ;
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( bNotLast  &&  m_iter == -- ( m_lUPointBs.end()))
      return false ;
  // assegno i dati
   if ( pdPar != nullptr)
      *pdPar = m_iter->dU ;
   if ( pptP != nullptr)
      *pptP = m_iter->ptP ;
   if ( pdBulge != nullptr)
      *pdBulge = m_iter->dB ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::GetNextUPoint( double* pdPar, Point3d* pptP, double* pdBulge, bool bNotLast) const
{
  // cerco il prossimo punto
   if ( m_iter == m_lUPointBs.end())
      return false ;
   ++ m_iter ;
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( bNotLast  &&  m_iter == -- ( m_lUPointBs.end()))
      return false ;
  // assegno i dati
   if ( pdPar != nullptr)
      *pdPar = m_iter->dU ;
   if ( pptP != nullptr)
      *pptP = m_iter->ptP ;
   if ( pdBulge != nullptr)
      *pdBulge = m_iter->dB ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::GetFirstUArc( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin, double* pdBulge) const
{
  // parametro e punto iniziali
   m_iter = m_lUPointBs.begin() ;
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->dU ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->ptP ;
  // bulge dell'arco (è attaccato al punto iniziale)
   if ( pdBulge != nullptr)
      *pdBulge = m_iter->dB ;
  // parametro e punto finali
   ++ m_iter ;
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->dU ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->ptP ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyArc::GetNextUArc( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin, double* pdBulge) const
{
  // parametro e punto iniziali (è il precedente finale)
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->dU ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->ptP ;
  // bulge (è attaccato al punto iniziale)
   if ( pdBulge != nullptr)
      *pdBulge = m_iter->dB ;
  // parametro e punto finali
   ++ m_iter ;
   if ( m_iter == m_lUPointBs.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->dU ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->ptP ;

   return true ;
}