//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : CurveLine.cpp       Data : 16.04.13          Versione : 1.1d1
// Contenuto : Implementazione della classe Segmento di Linea.
//
//
//
// Modifiche : 16.04.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "CurveLine.h"
#include "GeoObjFactory.h"
#include "\EgtDev\Include\EGnStringUtils.h"
#include <new>

using namespace std ;

//----------------------------------------------------------------------------
GEOOBJ_REGISTER( CRV_LINE, "C_LIN", CurveLine) ;

//----------------------------------------------------------------------------
CurveLine::CurveLine( void)
   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd()
{
}

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

//----------------------------------------------------------------------------
bool
CurveLine::Set( const Point3d& ptStart, const Point3d& ptEnd)
{
   m_PtStart = ptStart ;
   m_PtEnd = ptEnd ;
   m_nStatus = TO_VERIFY ;

   return Validate() ;
}

//----------------------------------------------------------------------------
CurveLine*
CurveLine::Clone( void) const
{
   CurveLine* pCrv ;

  // alloco oggetto
   pCrv = new(nothrow) CurveLine ;
   if ( pCrv != nullptr)
      *pCrv = *(const_cast<CurveLine*>(this)) ;

   return pCrv ;
}

//----------------------------------------------------------------------------
const string&
CurveLine::GetKey( void) const
{
   return GEOOBJ_GETKEY( CurveLine) ;
}

//----------------------------------------------------------------------------
bool
CurveLine::Save( ostream& osOut) const
{
  // parametri : punti iniziale e finale
   osOut << ToString( m_PtStart) ;
   osOut << ";" << ToString( m_PtEnd) << ";" << endl ;

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::Load( Scanner& TheScanner)
{
   string    sLine ;
   STRVECTOR vsParams ;


  // leggo la prossima linea
   if ( ! TheScanner.GetLine( sLine))
      return false ;
  // la divido in parametri
   Tokenize( sLine, ";", vsParams) ;
  // 2 parametri : punto iniziale e punto finale
   if ( vsParams.size() != 2)
      return false ;
  // recupero il punto iniziale
   if ( ! FromString( vsParams[0], m_PtStart))
      return false ;
  // recupero il punto finale
   if ( ! FromString( vsParams[1], m_PtEnd))
      return false ;
  // eseguo validazione
   return Validate() ;
}

//----------------------------------------------------------------------------
bool
CurveLine::GetLocalBBox( BBox3d& b3Loc) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;
  // assegno il box in locale
   b3Loc.Set( m_PtStart, m_PtEnd) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;
  // verifico validità del frame
   if ( frRef.GetType() == Frame3d::ERR)
      return false ;
  // porto gli estremi nel riferimento passato
   Point3d ptFrStart = m_PtStart ;
   ptFrStart.ToGlob( frRef) ;
   Point3d ptFrEnd = m_PtEnd ;
   ptFrEnd.ToGlob( frRef) ;
  // assegno il box nel riferimento
   b3Ref.Set( ptFrStart, ptFrEnd) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::Validate( void)
{
   if ( m_nStatus == TO_VERIFY)
      m_nStatus = ( ( SqDist( m_PtStart, m_PtEnd) > EPS_SMALL * EPS_SMALL) ? OK : ERR) ;

   return ( m_nStatus == OK) ;
}

//----------------------------------------------------------------------------
bool
CurveLine::GetStartPoint( Point3d& ptStart) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;

  // assegno il punto
   ptStart = m_PtStart ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
CurveLine::GetEndPoint( Point3d& ptEnd) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;
                          
  // assegno il punto
   ptEnd = m_PtEnd ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
CurveLine::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1, Vector3d* pvtDer2) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;

  // il parametro U deve essere compreso tra 0 e 1
   if ( dU < 0)
      dU = 0 ;
   else if ( dU > 1)
      dU = 1 ;

  // calcolo del punto
   ptPos = Media( m_PtStart, m_PtEnd, dU) ;

  // calcolo della derivata prima
   if ( pvtDer1 != nullptr)
      *pvtDer1 = m_PtEnd - m_PtStart ;

  // derivata seconda nulla
   if ( pvtDer2 != nullptr  &&  pvtDer1 != nullptr)
      pvtDer2->Set( 0, 0, 0) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::GetLength( double& dLen) const
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;

  // la lunghezza è la distanza tra gli estremi
   dLen = Dist( m_PtStart, m_PtEnd) ;

   return ( dLen > EPS_SMALL) ;
}

//----------------------------------------------------------------------------
bool
CurveLine::ApproxWithLines( double dLinTol, double dAngTolDeg, PolyLine& PL) const
{
  // la curva deve essere validata
   if ( m_nStatus != OK)
      return false ;

  // inserisco gli estremi
   PL.AddUPoint( 0, m_PtStart) ;
   PL.AddUPoint( 1, m_PtEnd) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::Invert( void)
{
  // verifico lo stato
   if ( m_nStatus != OK)
      return false ;

  // inverto i punti estremi
   swap(  m_PtStart, m_PtEnd) ;
  
   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::TrimStartAtParam( double dUTrim)
{
   double dLen ;


  // riporto i parametri nel loro range
   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;

  // recupero lunghezza
   if ( ! GetLength( dLen))
      return false ;

  // utilizzo il trim sulle lunghezze
   return TrimStartAtLen( dUTrim * dLen) ;
}

//----------------------------------------------------------------------------
bool
CurveLine::TrimEndAtParam( double dUTrim)
{
   double dLen ;


  // riporto i parametri nel loro range
   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;

  // recupero lunghezza
   if ( ! GetLength( dLen))
      return false ;

  // utilizzo il trim sulle lunghezze
   return TrimEndAtLen( dUTrim * dLen) ;
}

//----------------------------------------------------------------------------
bool
CurveLine::TrimStartAtLen( double dLenTrim)
{
   double dLen ;


  // lunghezze negative vengono considerate nulle
   dLenTrim = __max( dLenTrim, 0) ;

  // verifico che sia abbastanza lunga
   if ( ! GetLength( dLen))
      return false ;
   if ( ( dLen - dLenTrim) < EPS_SMALL)
      return false ;

  // eseguo il trim
   if ( dLenTrim > EPS_ZERO)
      m_PtStart = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;

  // con i controlli sopra fatti rimane validata

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::TrimEndAtLen( double dLenTrim)
{
   double dLen ;


  // lunghezze negative vengono considerate nulle
   dLenTrim = __max( dLenTrim, 0) ;

  // verifico che sia abbastanza lunga
   if ( ! GetLength( dLen))
      return false ;
   if ( dLenTrim < EPS_SMALL)
      return false ;

  // eseguo il trim
   if ( ( dLen - dLenTrim) > EPS_ZERO)
      m_PtEnd = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;

  // con i controlli sopra fatti rimane validata

   return true ;
}

//----------------------------------------------------------------------------
bool
CurveLine::Translate( const Vector3d& vtMove)
{
  // traslo i punti estremi
   m_PtStart.Translate( vtMove) ;
   m_PtEnd.Translate( vtMove) ;

   return true ;
}

//----------------------------------------------------------------------------
bool 
CurveLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
  // verifico validità dell'asse di rotazione
   if ( vtAx.IsSmall())
      return false ;

  // ruoto i punti estremi
   m_PtStart.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
   m_PtEnd.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;

   return true ;
}

//----------------------------------------------------------------------------
bool 
CurveLine::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // verifico non sia nulla
   if ( fabs( dCoeffX) < EPS_ZERO  &&  fabs( dCoeffY) < EPS_ZERO  &&  fabs( dCoeffZ) < EPS_ZERO)
      return false ;

  // scalo i punti estremi
   m_PtStart.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
   m_PtEnd.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
   m_nStatus = TO_VERIFY ;

   return Validate() ;
}

//----------------------------------------------------------------------------
bool 
CurveLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
{
  // verifico validità del piano di specchiatura
   if ( vtNorm.IsSmall())
      return false ;

  // specchio i punti estremi
   m_PtStart.Mirror( ptOn, vtNorm) ;
   m_PtEnd.Mirror( ptOn, vtNorm) ;

   return true ;
}

//----------------------------------------------------------------------------
bool 
CurveLine::ToGlob( const Frame3d& frRef)
{
  // verifico validità del frame
   if ( frRef.GetType() == Frame3d::ERR)
      return false ;

  // trasformo i punti estremi
   m_PtStart.ToGlob( frRef) ;
   m_PtEnd.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool 
CurveLine::ToLoc( const Frame3d& frRef)
{
  // verifico validità del frame
   if ( frRef.GetType() == Frame3d::ERR)
      return false ;

  // trasformo i punti estremi
   m_PtStart.ToLoc( frRef) ;
   m_PtEnd.ToLoc( frRef) ;

   return true ;
}