//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : PolyLine.cpp          Data : 22.12.13          Versione : 1.4l3
// Contenuto : Implementazione della classe PolyLine.
//
//
//
// Modifiche : 22.12.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "CurveLine.h"
#include "IntersLineLine.h"
#include "PolygonPlane.h"
#include "PointsPCA.h"
#include "GeoConst.h"
#include "CurveComposite.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkPolyLine.h"
#include "/EgtDev/Include/EGkPlane3d.h"
#include "/EgtDev/Include/EGkDistPointLine.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtNumUtils.h"

using namespace std ;

//----------------------------------------------------------------------------
PolyLine::PolyLine( void)
   : m_nRejected( 0), m_nTempProp{0,0}, m_iter( m_lUPoints.end())
{
}

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

//----------------------------------------------------------------------------
bool
PolyLine::Clear( void)
{
   m_nRejected = 0 ;
   m_lUPoints.clear() ;
   m_iter = m_lUPoints.end() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::AddUPoint( double dPar, const Point3d& ptP, bool bEndOrStart)
{
  // se da aggiungere in coda
   if ( bEndOrStart) {
     // se il punto è uguale all'ultimo (ignoro parametro), non lo inserisco ma ok
      if ( ! m_lUPoints.empty()  &&  AreSamePointApprox( ptP, m_lUPoints.back().first)) {
         ++ m_nRejected ;
         return true ;
      }
     // eseguo inserimento
      try {
         m_lUPoints.emplace_back( ptP, dPar) ;
      }
      catch (...) {
         return false ;
      }
   }
  // altrimenti si aggiunge in testa
   else {
     // se il punto è uguale al primo (ignoro parametro), non lo inserisco ma ok
      if ( ! m_lUPoints.empty()  &&  AreSamePointApprox( ptP, m_lUPoints.front().first)) {
         ++ m_nRejected ;
         return true ;
      }
     // eseguo inserimento
      try {
         m_lUPoints.emplace_front( ptP, dPar) ;
      }
      catch (...) {
         return false ;
      }
   }

   return true ;
}

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

//----------------------------------------------------------------------------
bool
PolyLine::ModifyLastParam( double dPar)
{
  // verifico esistano dei punti
   if ( m_lUPoints.empty())
      return false ;
  // eseguo la modifica
   m_lUPoints.back().second = dPar ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::EraseFirstUPoint( void)
{
   if ( m_lUPoints.empty())
      return false ;

   m_lUPoints.pop_front() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::EraseLastUPoint( void)
{
   if ( m_lUPoints.empty())
      return false ;

   m_lUPoints.pop_back() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::AddOffsetToU( double dOffset)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->second += dOffset ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Translate( const Vector3d& vtMove)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.Translate( vtMove) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.Mirror( ptOn, vtNorm) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.Shear( ptOn, vtNorm, vtDir, dCoeff) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::ToGlob( const Frame3d& frRef)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::ToLoc( const Frame3d& frRef)
{
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.ToLoc( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
{
  // se i due riferimenti coincidono, non devo fare alcunché
   if ( AreSameFrame( frOri, frDest))
      return true ;
  // ciclo sui punti
   for ( auto iter = m_lUPoints.begin() ; iter != m_lUPoints.end() ; ++ iter)
      iter->first.LocToLoc( frOri, frDest) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Join( PolyLine& PL, double dOffsetPar)
{
  // se l'altra polilinea non contiene alcunchè, esco con ok
   if ( PL.m_lUPoints.empty())
      return true ;
  // verifico che l'ultimo punto di questa polilinea coincida con il primo dell'altra
   if ( ! m_lUPoints.empty()  &&  ! AreSamePointApprox( m_lUPoints.back().first, PL.m_lUPoints.front().first))
      return false ;
  // cancello l'ultimo di questa
   EraseLastUPoint() ;
  // aggiungo eventuale offset all'altra
   if ( abs( dOffsetPar) > EPS_PARAM)
      PL.AddOffsetToU( dOffsetPar) ;
  // sposto i punti dall'altra polilinea a questa
   m_lUPoints.splice( m_lUPoints.end(), PL.m_lUPoints) ;   
      
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Split( double dU, PolyLine& PL)
{
  // pulisco la polilinea destinazione
   PL.Clear() ;
  // ricerca del punto in cui dividere
   auto iter = m_lUPoints.cbegin() ;
   while ( iter != m_lUPoints.end()  &&  iter->second < ( dU + EPS_PARAM))
      ++ iter ;
   if ( iter == m_lUPoints.end())
      return false ;
  // sposto i punti nell'altra polilinea
   PL.m_lUPoints.splice( PL.m_lUPoints.end(), m_lUPoints, iter, m_lUPoints.end()) ;
  // prepongo l'ultimo punto rimasto
   PL.m_lUPoints.push_front( m_lUPoints.back()) ; 
  // annullo l'iteratore corrente
   m_iter = m_lUPoints.end() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetLocalBBox( BBox3d& b3Loc) const
{
  // assegno il box in locale, scorrendo tutti i punti
   b3Loc.Reset() ;
   for ( const auto& UPnt : m_lUPoints)
      b3Loc.Add( UPnt.first) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::IsClosed( void) const
{
   if ( m_lUPoints.size() < 3)
      return false ;

   return ( AreSamePointApprox( m_lUPoints.front().first, m_lUPoints.back().first)) ; 
}

//----------------------------------------------------------------------------
bool
PolyLine::GetFirstUPoint( double* pdPar, Point3d* pptP, bool bNotLast) const
{
   m_iter = m_lUPoints.begin() ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( bNotLast  &&  m_iter == -- ( m_lUPoints.end())) {
      m_iter = m_lUPoints.end() ;
      return false ;
   }

   if ( pdPar != nullptr)
      *pdPar = m_iter->second ;
   if ( pptP != nullptr)
      *pptP = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetNextUPoint( double* pdPar, Point3d* pptP, bool bNotLast) const
{
   if ( m_iter == m_lUPoints.end())
      return false ;
   ++ m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( bNotLast  &&  m_iter == -- ( m_lUPoints.end())) {
      m_iter = m_lUPoints.end() ;
      return false ;
   }

   if ( pdPar != nullptr)
      *pdPar = m_iter->second ;
   if ( pptP != nullptr)
      *pptP = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetLastUPoint( double* pdPar, Point3d* pptP, bool bNotFirst) const
{
   m_iter = m_lUPoints.end() ;
   if ( m_iter == m_lUPoints.begin())
      return false ;
   -- m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( bNotFirst  &&  m_iter == m_lUPoints.begin()) {
      m_iter = m_lUPoints.end() ;
      return false ;
   }

   if ( pdPar != nullptr)
      *pdPar = m_iter->second ;
   if ( pptP != nullptr)
      *pptP = m_iter->first ;

   return true ;   
}

//----------------------------------------------------------------------------
bool
PolyLine::GetPrevUPoint( double* pdPar, Point3d* pptP, bool bNotFirst) const
{
   if ( m_iter == m_lUPoints.begin())
      return false ;
   -- m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( bNotFirst  &&  m_iter == m_lUPoints.begin()) {
      m_iter = m_lUPoints.end() ;
      return false ;
   }

   if ( pdPar != nullptr)
      *pdPar = m_iter->second ;
   if ( pptP != nullptr)
      *pptP = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetCurrUPoint( double* pdPar, Point3d* pptP) const
{
  // verifico validità punto corrente
   if ( m_iter == m_lUPoints.end())
      return false ;

   if ( pdPar != nullptr)
      *pdPar = m_iter->second ;
   if ( pptP != nullptr)
      *pptP = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetFirstULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin) const
{
  // parametro e punto iniziali
   m_iter = m_lUPoints.begin() ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->second ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->first ;

  // parametro e punto finali
   ++ m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->second ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetNextULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin) const
{
  // parametro e punto iniziali (è il precedente finale)
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->second ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->first ;

  // parametro e punto finali
   ++ m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->second ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetLastULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin) const
{
  // parametro e punto finali
   m_iter = m_lUPoints.end() ;
   if ( m_iter == m_lUPoints.begin())
      return false ;
   -- m_iter ;
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->second ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->first ;

  // parametro e punto iniziali
   if ( m_iter == m_lUPoints.begin())
      return false ;
   -- m_iter ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->second ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetPrevULine( double* pdIni, Point3d* pptIni, double* pdFin, Point3d* pptFin) const
{
  // parametro e punto finali
   if ( m_iter == m_lUPoints.end())
      return false ;
   if ( pdFin != nullptr)
      *pdFin = m_iter->second ;
   if ( pptFin != nullptr)
      *pptFin = m_iter->first ;

  // parametro e punto iniziali
   if ( m_iter == m_lUPoints.begin())
      return false ;
   -- m_iter ;
   if ( pdIni != nullptr)
      *pdIni = m_iter->second ;
   if ( pptIni != nullptr)
      *pptIni = m_iter->first ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::IsFlat( int& nRank, Point3d& ptCen, Vector3d& vtDir, double dToler) const
{
  // cerco le componenti principali (tramite PCA)
   Point3d ptP1, ptP2 ;
   PointsPCA ptsPCA ;
   for ( bool bFound = GetFirstLine( ptP1, ptP2) ; bFound ; bFound = GetNextLine( ptP1, ptP2)) {
      double dLen = Dist( ptP1, ptP2) ;
      ptsPCA.AddPoint( Media( ptP1, ptP2, 0.25), dLen / 2) ;
      ptsPCA.AddPoint( Media( ptP1, ptP2, 0.75), dLen / 2) ;
   }
  // recupero il rango, ovvero la dimensionalità dell'insieme di punti
   nRank = ptsPCA.GetRank() ;
  // se dimensione nulla, o non ci sono punti o sono tutti praticamente coincidenti
   if ( nRank == 0)
      return ptsPCA.GetCenter( ptCen) ;
  // se dimensione 1, allora i punti sono distribuiti su una linea
   if ( nRank == 1) {
     // assegno il centro e la direzione della linea (il verso è indifferente)
      ptsPCA.GetCenter( ptCen) ;
      ptsPCA.GetPrincipalComponent( 0, vtDir) ;
      return true ;
   }
  // altrimenti dimensione 2 o 3, allora è determinato un piano principale, verifico se tutti i punti vi giacciono
   // Center and normal vector
   ptsPCA.GetCenter( ptCen) ;
   Vector3d vtX, vtY ;
   ptsPCA.GetPrincipalComponent( 0, vtX) ;
   ptsPCA.GetPrincipalComponent( 1, vtY) ;
   vtDir = vtX ^ vtY ;
   if ( ! vtDir.Normalize()) {
     // riduco la dimensionalità a lineare
      nRank = 1 ;
     // assegno il centro e la direzione della linea (il verso è indifferente)
      ptsPCA.GetCenter( ptCen) ;
      vtDir = vtX ;
      return true ;
   }
   if ( vtDir.z < 0)
      vtDir.Invert() ;
   // Plane calculation
   Plane3d plPlane ;
   plPlane.Set( ptCen, vtDir) ;
   // Test each vertex to see if it is farther from plane than allowed max distance
   Point3d ptP ;
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
      double dDist = ( ( ptP - ORIG) * plPlane.GetVersN()) - plPlane.GetDist() ;
      if ( abs( dDist) > dToler)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::IsFlat( Plane3d& plPlane, double dToler) const
{
  // verifico non sia vuota
   if ( GetPointNbr() == 0) {
      plPlane.Reset() ;
      return false ;
   }
  // recupero dati sulla planarità della polilinea
   int nRank ;
   Point3d ptCen ;
   Vector3d vtDir ;
   bool bFlat = IsFlat( nRank, ptCen, vtDir, dToler) ;
   // imposto il piano a seconda della dimensionalità
   switch ( nRank) {
   case 0 :      // punto
      plPlane.Set( ptCen, Z_AX) ;
   case 1 :      // linea
      plPlane.Set( ptCen, FromUprightOrtho( vtDir)) ;
      break ;
   default :     // piana o 3d
      plPlane.Set( ptCen, vtDir) ;
      break ;
   }
   return bFlat ;
}

//----------------------------------------------------------------------------
bool
PolyLine::IsClosedAndFlat( Plane3d& plPlane, double& dArea, double dToler) const
{
  // Test if closed
   if ( ! IsClosed())
      return false ;
   Point3d ptP ;
  // Calcolo il centro (per minimizzare gli errori nelle successive operazioni)
   Point3d ptCen = ORIG ;
   int nCount = 0 ;
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
      ptCen += ptP ;
      ++ nCount ;
   }  
   ptCen /= nCount ;
   Vector3d vtMove = ptCen - ORIG ;
  // Compute a representative plane for the polygon (faccio il calcolo nel centro e poi traslo al contrario il piano)
   PolygonPlane PolyPlane ;
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP))
      PolyPlane.AddPoint( ptP - vtMove) ;
   if ( ! PolyPlane.GetPlane( plPlane)  ||  ! PolyPlane.GetArea( dArea)) {
      dArea = 0 ;
      return IsFlat( plPlane, dToler) ;
   }
   plPlane.Translate( vtMove) ;
  // Sistemo il piano per l'offset utilizzato
  // Test each vertex to see if it is farther from plane than allowed max distance
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
      double dDist = DistPointPlane( ptP, plPlane) ;
      if ( abs( dDist) > dToler)
         return false ;
   }
  // All points passed distance test, so polygon is considered planar
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetApproxLength( double& dLen) const
{
  // calcolo la lunghezza approssimata come somma di ogni singolo tratto lineare
   dLen = 0 ;
   Point3d ptIni, ptFin ;
   for ( bool bFound = GetFirstLine( ptIni, ptFin) ; bFound ; bFound = GetNextLine( ptIni, ptFin)) {
      dLen += ApproxDist( ptIni, ptFin) ;
   }
   return ( dLen > EPS_ZERO) ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetLength( double& dLen) const
{
  // calcolo la lunghezza come somma di ogni singolo tratto lineare
   dLen = 0 ;
   Point3d ptIni, ptFin ;
   for ( bool bFound = GetFirstLine( ptIni, ptFin) ; bFound ; bFound = GetNextLine( ptIni, ptFin)) {
      dLen += Dist( ptIni, ptFin) ;
   }
   return ( dLen > EPS_ZERO) ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetAreaXY( double& dArea) const
{
  // verifico sia chiusa
   if ( ! IsClosed())
      return false ;
  // calcolo l'area considerando solo XY (è la Z di Newell)
   dArea = 0 ;
   Point3d ptIni, ptFin ;
   for ( bool bFound = GetFirstLine( ptIni, ptFin) ; bFound ; bFound = GetNextLine( ptIni, ptFin)) {
      dArea += ( ptIni.x - ptFin.x) * ( ptIni.y + ptFin.y) ;   // projection on xy
   }
  // considero anche la linea tra l'ultimo e il primo punto perchè in alcuni casi potrebbero definire area 
  // significativa anche se sono coincidenti per le nostre tolleranze
   ptIni = ptFin ;
   GetFirstPoint( ptFin) ;
   if ( ! AreSamePointExact( ptIni, ptFin))
      dArea += ( ptIni.x - ptFin.x) * ( ptIni.y + ptFin.y) ;
   dArea = 0.5 * dArea ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetMaxDistanceFromLine( const Point3d& ptLine, const Vector3d& vtLine, double dLen,
                                  double& dMaxDist, bool bIsSegment) const
{
  // Verifico che la polilinea esista
   if ( GetPointNbr() < 1)
      return false ;
  // Calcolo la distanza di ogni punto dalla linea
   dMaxDist = 0 ;
   Point3d ptP ;
   for ( bool bFound = GetFirstPoint( ptP) ; bFound ; bFound = GetNextPoint( ptP)) {
      DistPointLine dstPL( ptP, ptLine, vtLine, dLen, bIsSegment) ;
      double dDist ;
      if ( dstPL.GetDist( dDist)  &&  dDist > dMaxDist)
         dMaxDist = dDist ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::AdjustForMaxSegmentLen( double dMaxLen)
{
   auto iter = m_lUPoints.begin() ;
  // se non ci sono punti, esco subito
   if ( iter == m_lUPoints.end())
      return false ;
  // imposto il primo punto come precedente
   double dUprec = iter->second ;
   Point3d ptPprec = iter->first ;
  // passo al secondo
   ++ iter ;
  // ciclo sui punti
   try {
      while ( iter != m_lUPoints.end()) {
        // recupero dati correnti
         double dUcurr = iter->second ;
         Point3d ptPcurr = iter->first ;
        // verifico lunghezza segmento dal precedente
         double dSqLen = SqDist( ptPprec, ptPcurr) ;
         if ( dSqLen > dMaxLen * dMaxLen) {
            double dLen = sqrt( dSqLen) ;
           // determino il numero di divisioni
            int nStep = int( dLen / dMaxLen + 0.999) ;
           // inserisco i punti necessari
            for ( int i = 1 ; i < nStep ; ++ i) {
               double dCoeff = double( i) / nStep ;
               m_lUPoints.insert( iter, POINTU( Media( ptPprec, ptPcurr, dCoeff),
                                                (( 1 - dCoeff) * dUprec + dCoeff * dUcurr))) ;
            }
         }
        // passo al successivo
         dUprec = dUcurr ;
         ptPprec = ptPcurr ;
         ++ iter ;
      }
   }
   catch (...) {
      return false ;
   }

   return true ;
}

//-----------------------------------------------------------------------------
static bool
DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const int nIndStart,
                              const int nIndEnd, INTVECTOR& vInd)
{
  // se indici uguali, ritorno
   if ( nIndStart == nIndEnd)
      return true ;

  // distanza massima e indice del punto associato
   double dMaxSqDist = 0. ;
   int nMaxInd = 0 ;

  // scorro i punti intermedi tra nIndStart e nIndEnd
   for ( int i = nIndStart + 1 ; i < nIndEnd ; ++ i) {
      double dCurrSqDist = 0. ;
     // distanza tra il punto attuale e la retta tra i punti di indici nIndStart ed nIndEnd
      DistPointLine DPL( vPtU[i].first, vPtU[nIndStart].first, vPtU[nIndEnd].first) ;
      if ( DPL.GetSqDist( dCurrSqDist)  &&  dCurrSqDist > dMaxSqDist) {
        // aggiorno i parametri
         dMaxSqDist = dCurrSqDist ;
         nMaxInd = i ;
      }
   }

  // se la distanza massima trovata è sopra la tolleranza, allora controllo la parte di PolyLine tra
  // (nIndStart, nMaxInd) e quella tra (nMaxInd, nIndEnd)
   if ( dMaxSqDist > dSqTol) {
     // inserisco il punto
      vInd.push_back( nMaxInd) ;
     // split
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nIndStart, nMaxInd, vInd)  ||
           ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, nIndEnd, vInd))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::RemoveAlignedPoints( double dToler, bool bStartEnd)
{
  // se non ci sono almeno 3 punti, esco subito
   if ( m_lUPoints.size() < 3)
      return true ;
  // controllo minimo valore di tolleranza
   dToler = max( dToler, LIN_TOL_MIN) ;
   double dSqTol = dToler * dToler ;

  // vettore contenente i punti della polyline
   PNTUVECTOR vPtU ; vPtU.reserve( m_lUPoints.size()) ;
   for ( const auto& ptCurr : m_lUPoints)
      vPtU.emplace_back( ptCurr) ;

  // vettore indici dei punti rimanenti
   INTVECTOR vInd ; vInd.reserve( vPtU.size()) ;

  // se aperta
   if ( ! IsClosed()) {
     // considero tutti i punti della PolyLine
      vInd.push_back( 0) ;
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
         return false ;
      vInd.push_back( int( vPtU.size()) - 1) ;
   }
  // altrimenti chiusa
   else {
     // cerco il punto più distante dal primo
      double dMaxDist = 0. ;
      int nMaxInd = 0 ;
      for ( int i = 1 ; i < int( vPtU.size()) ; ++ i) {
         double dCurrDist = Dist( vPtU[0].first, vPtU[i].first) ;
         if ( dCurrDist > dMaxDist) {
            dMaxDist = dCurrDist ;
            nMaxInd = i ;
         }
      }
     // recupero due PolyLine di approssimazione
      vInd.push_back( 0) ;
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, nMaxInd, vInd))
         return false ;
      vInd.push_back( nMaxInd) ;
      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
         return false ;
      vInd.push_back( int( vPtU.size()) - 1) ;
   }

  // ordino in senso crescente
   sort( vInd.begin(), vInd.end()) ;

  // se richiesto e chiusa e almeno 4 punti rimasti, controllo allineamento dell'inizio con precedente e successivo rimasti
   if ( bStartEnd  &&  IsClosed()  &&  vInd.size() >= 4) {
      if ( DistPointLine( vPtU[vInd[0]].first, vPtU[vInd[1]].first, vPtU[vInd[int(vInd.size())-2]].first).IsEpsilon( dToler)) {
         vInd.erase( vInd.begin()) ;
         vInd.back() = vInd.front() ;
      }
   }

  // rimetto in lista i soli punti rimasti
   m_lUPoints.clear() ;
   for ( auto Ind : vInd)
      m_lUPoints.push_back( vPtU[Ind]) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::ApproxOnSide( const Vector3d& vtN,  bool bLeftSide, double dToler)
{
  // eseguo una prima approssimazione
   if ( ! MyApproxOnSide( vtN, bLeftSide, dToler))
      return false ;

  // se polilinea aperta, finito
   if ( ! IsClosed())
      return true ;

  // *** polilinea chiusa : devo sistemare a cavallo dell'inizio/fine ***

  // sposto l'inizio dalla parte opposta
   MyChangeStart( int( m_lUPoints.size() / 2)) ;
  // rifaccio l'approssimazione con 3/4 della tolleranza ammessa
   if ( ! MyApproxOnSide( vtN, bLeftSide, 0.75 * dToler))
      return false ;
  // risposto l'inizio dalla parte opposta, quindi lo porto vicino all'originale
   MyChangeStart( int( m_lUPoints.size() / 2)) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::MyChangeStart( int nPos)
{
  // solo per polilinee chiuse
   if ( ! IsClosed())
      return false ;
  // cancello l'ultimo punto ( coincide con il primo)
   m_lUPoints.pop_back() ;
  // sposto la parte iniziale dei punti alla fine
   m_lUPoints.splice( m_lUPoints.end(), m_lUPoints, m_lUPoints.begin(), next( m_lUPoints.begin(), nPos)) ;
  // aggiungo il punto finale come copia dell'iniziale
   m_lUPoints.push_back( m_lUPoints.front()) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::MyApproxOnSide( const Vector3d& vtN,  bool bLeftSide, double dToler)
{
  // se non ci sono almeno 3 punti, esco subito
   if ( m_lUPoints.size() < 3)
      return true ;
  // coefficienti deduzione tolleranza
   const double COEFF_TOL = 0.90 ;
  // punto precedente
   auto precP = m_lUPoints.begin() ;
  // punto corrente
   auto currP = next( precP) ;
  // punto successivo
   auto nextP = next( currP) ;
  // assegno la tolleranza corrente
   double dCurrToler = dToler ;
  // mentre esiste un successivo
   while ( nextP != m_lUPoints.end()) {
     // --- si verifica se possibile eliminare il punto corrente rimanendo dal lato voluto e in tolleranza ---
     // distanza del punto corrente dal segmento che unisce gli adiacenti
      DistPointLine dPL( currP->first, precP->first, nextP->first) ;
      double dSqDist = SQ_INFINITO ;
      dPL.GetSqDist( dSqDist) ;
     // se punti allineati
      if ( dSqDist < SQ_EPS_SMALL) {
        // ripristino la tolleranza corrente
         dCurrToler = dToler ;
        // elimino il corrente
         m_lUPoints.erase( currP) ;
        // avanzo con corrente e successivo
         currP = nextP ;
         ++ nextP ;
         continue ;
      }
     // se lato sinistro e gira a sinistra o lato destro e gira a destra
      double dCrossXY = ( ( currP->first - precP->first) ^ ( nextP->first - currP->first)) * vtN ;
      if ( ( bLeftSide  &&  dCrossXY > 0)  ||  ( ! bLeftSide  &&  dCrossXY < 0)) {
        // se eliminabile
         if ( dSqDist < dCurrToler * dCurrToler) {
           // diminuisco la tolleranza corrente dell'errore attuale
            dCurrToler -= COEFF_TOL * sqrt( dSqDist) ;
           // elimino il punto corrente
            m_lUPoints.erase( currP) ;
           // avanzo con corrente e successivo
            currP = nextP ;
            ++ nextP ;
            continue ;
         }
      }
     // --- si verifica se possibile elimare segmento da corrente a successivo rimanendo in tolleranza e dal lato voluto --- 
     // punto successivo del successivo
      auto nex2P = next( nextP) ;
      if ( nex2P != m_lUPoints.end()) {
         double dCros2XY = ( ( nextP->first - currP->first) ^ ( nex2P->first - nextP->first)) * vtN ;
        // se lato sinistro e 2 giri a destra o lato destro e 2 giri a sinistra
         if ( ( bLeftSide  &&  dCrossXY < 0  &&  dCros2XY < 0)  ||
              ( ! bLeftSide  &&  dCrossXY > 0  &&  dCros2XY > 0)) {
           // calcolo del punto di intersezione tra i segmenti precP-currP e nextP-next2P, allungati al centro
            CurveLine Line1, Line2 ;
            if ( Line1.Set( precP->first, currP->first)  &&
                 Line2.Set( nextP->first, nex2P->first)) {
              // se la normale non coincide con l'asse Z, devo portare le linee nel riferimento OCS di questa
               Frame3d frNorm ;
               if ( ! vtN.IsZplus()  &&  ! vtN.IsZminus())
                  frNorm.Set( ORIG, vtN) ;
               Line1.ToLoc( frNorm) ;
               Line2.ToLoc( frNorm) ;
               IntersLineLine IntLL( Line1, Line2, false) ;
               IntCrvCrvInfo IntInfo ;
               if ( IntLL.GetIntCrvCrvInfo( IntInfo)  &&
                    ! IntInfo.bOverlap  &&  IntInfo.IciA[0].dU > 1  &&  IntInfo.IciB[0].dU < 0) {
                  Point3d ptInt = 0.5 * ( IntInfo.IciA[0].ptI + IntInfo.IciB[0].ptI) ;
                  ptInt.ToGlob( frNorm) ;
                 // verifico che distanza dell'intersezione dal segmento currP-nextP sia inferiore a tolleranza corrente
                  DistPointLine dIL( ptInt, currP->first, nextP->first) ;
                  double dSqDist2 = SQ_INFINITO ;
                  dIL.GetSqDist( dSqDist2) ;
                 // se eliminabile
                  if ( dSqDist2 < dCurrToler * dCurrToler) {
                    // diminuisco la tolleranza corrente dell'errore attuale
                     dCurrToler -= COEFF_TOL * sqrt( dSqDist2) ;
                    // sposto il successivo sull'intersezione e ne aggiorno il parametro
                     nextP->first = ptInt ;
                     nextP->second = 0.5 * ( currP->second + nextP->second) ;
                    // elimino il punto corrente
                     m_lUPoints.erase( currP) ;
                    // avanzo con corrente e successivo
                     currP = nextP ;
                     nextP = nex2P ;
                     continue ;
                  }
               }
            }
         }
      }
     // non è stato eliminato alcunché
     // ripristino la tolleranza corrente
      dCurrToler = dToler ;
     // avanzo il terzetto di uno step
      precP = currP ;
      currP = nextP ;
      ++ nextP ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::MakeConvex( const Vector3d& vtN,  bool bLeftSide)
{
  // eseguo una prima modifica
   if ( ! MyMakeConvex( vtN, bLeftSide))
      return false ;

  // se polilinea aperta, finito
   if ( ! IsClosed())
      return true ;

  // *** polilinea chiusa : devo sistemare a cavallo dell'inizio/fine ***

  // sposto l'inizio dalla parte opposta
   MyChangeStart( int( m_lUPoints.size() / 2)) ;
  // rifaccio la modifica
   if ( ! MyMakeConvex( vtN, bLeftSide))
      return false ;
  // risposto l'inizio dalla parte opposta, quindi lo porto vicino all'originale
   MyChangeStart( int( m_lUPoints.size() / 2)) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::MyMakeConvex( const Vector3d& vtN,  bool bLeftSide)
{
  // ciclo i controlli finchè non ci sono rimozioni
   bool bRemoved = true ;
   while ( bRemoved) {
      bRemoved = false ;
     // se non ci sono almeno 3 punti, esco subito
      if ( m_lUPoints.size() < 3)
         return true ;
     // punto precedente
      auto precP = m_lUPoints.begin() ;
     // punto corrente
      auto currP = next( precP) ;
     // punto successivo
      auto nextP = next( currP) ;
     // mentre esiste un successivo
      while ( nextP != m_lUPoints.end()) {
        // --- si verifica se possibile eliminare il punto corrente rimanendo dal lato voluto ---
        // se lato sinistro e gira a sinistra o lato destro e gira a destra
         double dCrossXY = ( ( currP->first - precP->first) ^ ( nextP->first - currP->first)) * vtN ;
         if ( ( bLeftSide  &&  dCrossXY > - EPS_ZERO)  ||  ( ! bLeftSide  &&  dCrossXY < EPS_ZERO)) {
           // elimino il punto corrente
            m_lUPoints.erase( currP) ;
           // avanzo con corrente e successivo
            currP = nextP ;
            ++ nextP ;
           // dichiaro rimozione
            bRemoved = true ;
            continue ;
         }
        // non è stato eliminato alcunché : avanzo il terzetto di uno step
         precP = currP ;
         currP = nextP ;
         ++ nextP ;
      }
     // se rimasti due punti coincidenti, elimino il secondo
      if ( m_lUPoints.size() == 2  &&
           AreSamePointApprox( m_lUPoints.front().first, m_lUPoints.back().first)) {
         m_lUPoints.pop_back() ;
         return false ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Invert( bool bInvertU)
{
  // verifico non sia vuota
   if ( m_lUPoints.empty())
      return true ;
  // inverto la lista
   m_lUPoints.reverse() ;
  // se richiesto, inverto anche il parametro U
   if ( bInvertU) {
     // recupero il primo valore di U che è il vecchio finale ed è il riferimento di inversione
      double dUfin = m_lUPoints.front().second ;
     // ciclo su tutti gli elementi
      for ( auto& UPoint : m_lUPoints) {
         UPoint.second = dUfin - UPoint.second ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::MyRemoveSamePoints( double dToler)
{
  // elimino i punti consecutivi diventati coincidenti (almeno 2)
   if ( m_lUPoints.size() < 2)
      return true ;
  // punto precedente
   auto precP = m_lUPoints.begin() ;
  // punto corrente
   auto currP = next( precP) ;
  // mentre esiste un corrente
   while ( currP != m_lUPoints.end()) {
     // se coincidono
      if ( AreSamePointEpsilon( precP->first, currP->first, dToler)) {
        // elimino il punto corrente
         currP = m_lUPoints.erase( currP) ;
        // il precedente rimane inalterato
      }
     // altrimenti da tenere
      else {
        // avanzo la coppia di uno step
         precP = currP ;
         ++ currP ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Flatten( double dZ)
{
  // verifico non sia vuota
   if ( m_lUPoints.empty())
      return true ;
  // ciclo su tutti gli elementi per portarli alla Z indicata
   for ( auto& UPoint : m_lUPoints)
      UPoint.first.z = dZ ;
  // elimino i punti consecutivi diventati coincidenti
   MyRemoveSamePoints() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::FlattenInAutoPlane( double dToler)
{
  // verifico non sia vuota
   if ( m_lUPoints.empty())
      return true ;
  // recupero dati sulla planarità della polilinea
   int nRank ;
   Point3d ptCen ;
   Vector3d vtDir ;
   bool bFlat = IsFlat( nRank, ptCen, vtDir, dToler) ;
  // se non planare entro la tolleranza, esco
   if ( ! bFlat)
      return false ;
  // se punto o linea, non devo fare alcunché
   if ( nRank == 0  ||  nRank == 1)
      return true ;
  // assegno il piano medio
   Plane3d plPlane ;
   plPlane.Set( ptCen, vtDir) ;
  // proietto i punti su questo piano
   for ( auto& UPoint : m_lUPoints)
      UPoint.first = ProjectPointOnPlane( UPoint.first, plPlane) ;
  // elimino i punti consecutivi diventati coincidenti
   MyRemoveSamePoints() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetConvexHullXY( PNTVECTOR& vConvHull) const
{
   int nSize = int( m_lUPoints.size()) ;
   if ( nSize == 0)
      return false ;
  // inserisco i punti in un array ( considero solo x e y, annullo le z)
   PNTVECTOR vPnt( nSize) ;
   int k = 0 ;
   for ( const auto& Pnt : m_lUPoints)
      vPnt[k++] = Point3d( Pnt.first.x, Pnt.first.y, 0) ;
  // ordino secondo le X crescenti
   sort( vPnt.begin(), vPnt.end(), 
         []( const Point3d& a, const Point3d& b) { return ( a.x < b.x) ; }) ;
  // elimino eventuali punti coincidenti
   for ( int i = 0 ; i < nSize ; ++ i) {
      for ( int j = i + 1 ; j < nSize ; ++ j) {
         if ( ( vPnt[j].x - vPnt[i].x) > EPS_SMALL)
            break ;
         else if ( AreSamePointXYApprox( vPnt[i], vPnt[j])) {
            vPnt.erase( vPnt.begin() + j) ;
            -- nSize ;
         }
      }
   }
  // applico l'algoritmo di Andrew
   int j = 0 ;
   vConvHull.resize( 2 * nSize) ;
  // costruisco la parte inferiore
   for ( int i = 0 ; i < nSize ; ++ i) {
      while ( j >= 2  &&  CrossXY( vConvHull[j-1] - vConvHull[j-2], vPnt[i] - vConvHull[j-2]) <= 0)
         -- j ;
      vConvHull[j++] = vPnt[i] ;
   }
  // costruisco la parte superiore
   for ( int i = nSize - 2, t = j + 1 ; i >= 0 ; -- i) {
      while ( j >= t  &&  CrossXY( vConvHull[j-1] - vConvHull[j-2], vPnt[i] - vConvHull[j-2]) <= 0)
         -- j ;
      vConvHull[j++] = vPnt[i] ;
   }
   vConvHull.resize( j - 1) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::GetMinAreaRectangleXY( Point3d& ptCen, Vector3d& vtAx, double& dLen, double& dHeight) const
{
  // Convex Hull
   PNTVECTOR vConvHull ;
   if ( ! GetConvexHullXY( vConvHull))
      return false ;
   // all points in ConvexHull are different, minimum a segment
   int nCount = int( vConvHull.size()) ;
   if ( nCount < 2)
      return false ;

  // Starting edge nCount-1 -> 0
   int l = 0, m = 0, n = 0 ;
   double dMinArea = SQ_INFINITO ;
   {
     // Edge indexes
      int i = 0 ;
      int j = nCount - 1 ;
     // Edge versor
      Vector3d vtE0 = vConvHull[i] -  vConvHull[j] ;
      vtE0.Normalize() ;
     // Edge perpendicular versor
      Vector3d vtE1 = Vector3d( -vtE0.y, vtE0.x, 0) ;
     // Loop through all points to get maximum extents
      double dMin0 = INFINITO, dMax0 = - INFINITO, dMin1 = 0, dMax1 = - INFINITO ;
      for ( int k = 0 ; k < nCount ; ++ k) {
         // Project points onto axes vtE0 and vtE1 and keep track
         // of minimum and maximum values along both axes
         Vector3d vtDiff = vConvHull[k] - vConvHull[j] ;
         double dSca = ScalarXY( vtDiff, vtE0) ;
         if ( dSca < dMin0) {
            dMin0 = dSca ;
            l = k ;
         }
         if ( dSca > dMax0) {
            dMax0 = dSca ;
            m = k ;
         }
         dSca = ScalarXY( vtDiff, vtE1) ;
         if ( dSca > dMax1) {
            dMax1 = dSca ;
            n = k ;
         }
      }
     // Remember area, center and axes
      dMinArea = ( dMax0 - dMin0) * ( dMax1 - dMin1) ;
      ptCen = vConvHull[j] + 0.5 * (( dMin0 + dMax0) * vtE0 + ( dMin1 + dMax1) * vtE1) ;
      vtAx = vtE0 ;
      dLen = dMax0 - dMin0 ;
      dHeight = dMax1 - dMin1 ;
   }

  // Loop through all other edges (j trails i by 1)
   for ( int i = 1, j = 0 ; i < nCount ; j = i, ++ i) {
     // Get current edge, normalized
      Vector3d vtE0 = vConvHull[i] -  vConvHull[j] ;
      vtE0.Normalize() ;
     // Get an axis vtE1 orthogonal to edge vtE0
      Vector3d vtE1 = Vector3d( -vtE0.y, vtE0.x, 0) ;
     // Find new min on vtE0
      double dMin0 = ScalarXY( ( vConvHull[l] - vConvHull[j]), vtE0) ;
      for ( int k = 0 ; k < nCount ; ++ k) {
         int lnext = ( l + 1) % nCount ;
         double dMin0next = ScalarXY( (vConvHull[lnext] - vConvHull[j]), vtE0) ;
         if ( dMin0next < dMin0) {
            dMin0 = dMin0next ;
            l = lnext ;
         }
         else
            break ;
      }
     // Find new max on vtE0
      double dMax0 = ScalarXY( ( vConvHull[m] - vConvHull[j]), vtE0) ;
      for ( int k = 0 ; k < nCount ; ++ k) {
         int mnext = ( m + 1) % nCount ;
         double dMax0next = ScalarXY( (vConvHull[mnext] - vConvHull[j]), vtE0) ;
         if ( dMax0next > dMax0) {
            dMax0 = dMax0next ;
            m = mnext ;
         }
         else
            break ;
      }
     // Find new min on vtE1
      double dMin1 = 0 ;
     // Find new max on vtE1
      double dMax1 = ScalarXY( ( vConvHull[n] - vConvHull[j]), vtE1) ;
      for ( int k = 0 ; k < nCount ; ++ k) {
         int nnext = ( n + 1) % nCount ;
         double dMax1next = ScalarXY( (vConvHull[nnext] - vConvHull[j]), vtE1) ;
         if ( dMax1next > dMax1) {
            dMax1 = dMax1next ;
            n = nnext ;
         }
         else
            break ;
      }
      double dArea = ( dMax0 - dMin0) * ( dMax1 - dMin1) ;
     // If best so far, remember area, center, and axes
      if ( dArea < dMinArea) {
         dMinArea = dArea ;
         ptCen = vConvHull[j] + 0.5 * (( dMin0 + dMax0) * vtE0 + ( dMin1 + dMax1) * vtE1) ;
         vtAx = vtE0 ;
         dLen = dMax0 - dMin0 ;
         dHeight = dMax1 - dMin1 ;
      }
   }

  // Axis aligned with max dimension
   if ( dHeight > dLen) {
      vtAx.Rotate( Z_AX, 0, 1) ;
      swap( dLen, dHeight) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PolyLine::Trim( const Plane3d& plPlane, bool bInVsOut)
{
  // se vuota non faccio alcunché
   if ( m_lUPoints.empty())
      return false ;

  // determino le intersezioni dei lati con il piano
   int nIntPos = - 1 ;
   auto prevUP = m_lUPoints.begin() ;
   double dPrevDist = ( prevUP->first - ORIG) * plPlane.GetVersN() - plPlane.GetDist() ;
   auto currUP = next( prevUP) ;
   while ( currUP != m_lUPoints.end()) {
     // se non inizializzato e  precedente in zona vietata, ne salvo l'indice
      if ( nIntPos == -1  &&
           ( ( bInVsOut  &&  dPrevDist > EPS_SMALL)  ||
             ( ! bInVsOut  &&  dPrevDist < - EPS_SMALL)))
         nIntPos = int( distance( m_lUPoints.begin(), prevUP)) ;
     // distanze del punto dal piano
      double dCurrDist = ( currUP->first - ORIG) * plPlane.GetVersN() - plPlane.GetDist() ;
     // se il lato attraversa il piano, inserisco il punto di intersezione nel poligono
      if ( ( dPrevDist > EPS_SMALL  &&  dCurrDist < - EPS_SMALL)  ||
           ( dPrevDist < - EPS_SMALL  &&  dCurrDist > EPS_SMALL)) {
         double dCoeff = abs( dPrevDist) / ( abs( dPrevDist) + abs( dCurrDist)) ;
         Point3d ptInt = Media( prevUP->first, currUP->first, dCoeff) ;
         double dU = ( 1 - dCoeff) * prevUP->second + dCoeff * currUP->second ;
         m_lUPoints.insert( currUP, { ptInt, dU}) ;
      }
     // passo al successivo
      prevUP = currUP ;
      currUP = next( currUP) ;
      dPrevDist = dCurrDist ;
   }

  // se chiusa, sposto l'inizio su eventuale primo punto di intersezione con il piano
   if ( IsClosed()  &&  nIntPos != -1)
      MyChangeStart( nIntPos) ;

  // elimino i punti che non rispettano la posizione rispetto al piano
   currUP = m_lUPoints.begin() ;
   while ( currUP != m_lUPoints.end()) {
      double dDist = ( currUP->first - ORIG) * plPlane.GetVersN() - plPlane.GetDist() ;
      if ( ( bInVsOut  &&  dDist > EPS_SMALL)  ||
           ( ! bInVsOut  &&  dDist < - EPS_SMALL)) {
         currUP = m_lUPoints.erase( currUP) ;
      }
      else
         currUP = next( currUP) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
bool
DistPointPolyLine( const Point3d& ptP, const PolyLine& plPoly, double& dDist)
{
   double dDummy ;
   return DistPointPolyLine( ptP, plPoly, dDist, dDummy) ;
}

//----------------------------------------------------------------------------
bool
DistPointPolyLine( const Point3d& ptP, const PolyLine& plPoly, double& dDist, double& dMinDistPar)
{
  // La polilinea deve contenere almeno due punti
   if ( plPoly.GetPointNbr() < 2)
      return false ;
  // Ciclo sui punti della polilinea
   dDist = INFINITO ;
   int nSeg = -1 ;
   Point3d ptStart, ptEnd ;
   plPoly.GetFirstPoint( ptStart) ;
   while ( plPoly.GetNextPoint( ptEnd)) {
      ++ nSeg ;
     // distanza del punto dal segmento della polilinea
      DistPointLine PointLineDistCalc( ptP, ptStart, ptEnd) ;
      double dPlDist ;
      PointLineDistCalc.GetDist( dPlDist) ;
      if ( dPlDist < dDist) {
         dDist = dPlDist ;
         PointLineDistCalc.GetParamAtMinDistPoint( dMinDistPar) ;
         dMinDistPar += nSeg ;
      }
     // assegno nuovo inizio
      ptStart = ptEnd ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
IsPointInsidePolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler)
{
  // La polilinea deve essere chiusa e piatta, altrimenti non ha senso parlare di interno
   Plane3d plPlane ;
   double dArea ;
   if ( ! plPoly.IsClosedAndFlat( plPlane, dArea, 10 * EPS_SMALL))
      return false ;
  // Il punto deve giacere nel piano della polilinea
   if ( ! PointInPlaneEpsilon( ptP, plPlane, 10 * EPS_SMALL))
      return false ;
  // Riferimento alla lista dei punti
   PNTULIST& List = const_cast<PolyLine&>( plPoly).GetUPointList() ;
  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   Point3d ptMinDist ;
   auto itMinDistEnd = List.end() ;
   auto itStart = List.begin() ;
   auto itEnd = next( itStart) ;
   for ( ; itEnd != List.end() ; ++ itStart, ++ itEnd) {
     // Distanza del punto dal segmento corrente
      DistPointLine dDistCalc( ptP, itStart->first, itEnd->first) ;
      double dSqDist ;
      if ( dDistCalc.GetSqDist( dSqDist)  &&  dSqDist < dMinSqDist) {
         dMinSqDist = dSqDist ;
         dDistCalc.GetMinDistPoint( ptMinDist) ;
         itMinDistEnd = itEnd ;
      }
   }
  // Determino tangente di riferimento
   Vector3d vtTang ;
  // se minima distanza nell'estremo iniziale del segmento
   if ( AreSamePointApprox( ptMinDist, prev( itMinDistEnd)->first)) {
     // direzione del segmento
      Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
      vtCurrTg.Normalize() ;
     // direzione del segmento precedente
      Vector3d vtPrevTg ;
      if ( prev( itMinDistEnd) != List.begin())
         vtPrevTg = prev( itMinDistEnd)->first - prev( itMinDistEnd, 2)->first ;
      else
         vtPrevTg = prev( itMinDistEnd)->first - next( List.rbegin())->first ;
      vtPrevTg.Normalize() ;
     // tangente media
      vtTang = vtPrevTg + vtCurrTg ;
      vtTang.Normalize() ;
   }
  // se altrimenti minima distanza nell'estremo finale del segmento
   else if ( AreSamePointApprox( ptMinDist, itMinDistEnd->first)) {
     // direzione del segmento
      Vector3d vtCurrTg = itMinDistEnd->first - prev( itMinDistEnd)->first ;
      vtCurrTg.Normalize() ;
     // direzione del segmento successivo
      Vector3d vtNextTg ;
      if ( next( itMinDistEnd) != List.end())
         vtNextTg = next( itMinDistEnd)->first - itMinDistEnd->first ;
      else
         vtNextTg = next( List.begin())->first - itMinDistEnd->first ;
      vtNextTg.Normalize() ;
     // tangente media
      vtTang = vtCurrTg + vtNextTg ;
      vtTang.Normalize() ;
   }
  // altrimenti minima distanza con l'interno
   else {
      vtTang = itMinDistEnd->first - prev( itMinDistEnd)->first ;
   }
  // Determino la posizione del punto
   Vector3d vtDiff = ptP - ptMinDist ;
   Vector3d vtOut = vtTang ^ plPlane.GetVersN() ;
   vtOut.Normalize() ;
   return ( vtDiff * vtOut < -dToler) ;
}

//----------------------------------------------------------------------------
bool
GetPointParamOnPolyLine( const Point3d& ptP, const PolyLine& plPoly, double dToler, double& dPar)
{
  // La polilinea deve contenere almeno due punti
   if ( plPoly.GetPointNbr() < 2)
      return false ;
  // Ciclo sui punti della polilinea
   int nSeg = -1 ;
   double dMinSqDist = SQ_INFINITO ;
   dPar = -1 ;
   Point3d ptStart, ptEnd ;
   plPoly.GetFirstPoint( ptStart) ;
   while ( plPoly.GetNextPoint( ptEnd)) {
     // aggiorno l'indice
      ++ nSeg ;
     // distanza del punto dal segmento della polilinea
      DistPointLine dDistCalc( ptP, ptStart, ptEnd) ;
      double dSqDist ;
      if ( dDistCalc.GetSqDist( dSqDist)  &&  dSqDist < dMinSqDist) {
         dMinSqDist = dSqDist ;
         double dSegPar ;
         dDistCalc.GetParamAtMinDistPoint( dSegPar) ;
         dPar = nSeg + dSegPar ;
      }
     // assegno nuovo inizio
      ptStart = ptEnd ;
   }
  // Il punto è sulla linea se la sua distanza rispetta la tolleranza
   return ( dMinSqDist < dToler * dToler) ;
}

//----------------------------------------------------------------------------
bool
ChangePolyLineStart( PolyLine& plPoly, const Point3d& ptNewStart, double dToler)
{
  // La polilinea deve essere chiusa
   if ( ! plPoly.IsClosed())
      return false ;
  // Riferimento alla lista dei punti
   PNTULIST& LoopList = const_cast<PolyLine&>( plPoly).GetUPointList() ;
  // Se il punto inziale è già quello, non faccio nulla
   if ( AreSamePointEpsilon( LoopList.begin()->first, ptNewStart, dToler))
      return true ;

  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   auto itMinDistEnd = LoopList.end() ;
   auto itStart = LoopList.begin() ;
   auto itEnd = next( itStart) ;
   for ( ; itEnd != LoopList.end() ; ++ itStart, ++ itEnd) {
     // Distanza del punto dal segmento corrente
      DistPointLine dDistCalc( ptNewStart, itStart->first, itEnd->first) ;
      double dSqDist ;
      if ( dDistCalc.GetSqDist( dSqDist)  &&  dSqDist < dMinSqDist) {
         dMinSqDist = dSqDist ;
         itMinDistEnd = itEnd ;
      }
   }
  // Se il punto non sta sulla polilinea, non ha senso cambiare l'inizio
   if ( dMinSqDist > dToler * dToler)
      return false ;
  // Se il punto non coincide con un vertice, lo aggiungo
   auto itNewStart = LoopList.end() ;
   if ( AreSamePointApprox( ptNewStart, prev( itMinDistEnd)->first))
      itNewStart = prev( itMinDistEnd) ;
   else if ( AreSamePointApprox( ptNewStart, itMinDistEnd->first))
      itNewStart = itMinDistEnd ;
   else
      itNewStart = LoopList.emplace( itMinDistEnd, ptNewStart, 0) ;
  // Cancello l'ultimo punto ( coincide con il primo)
   LoopList.pop_back() ;
  // Sposto la parte iniziale dei punti alla fine
   LoopList.splice( LoopList.end(), LoopList, LoopList.begin(), itNewStart) ;
  // Aggiungo il punto finale come copia dell'iniziale
   LoopList.push_back( LoopList.front()) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SplitPolyLineAtPoint( const PolyLine& plPoly, const Point3d& ptP, double dToler, PolyLine& plPoly1, PolyLine& plPoly2)
{
  // La polilinea deve contenere almeno due punti
   if ( plPoly.GetPointNbr() < 2)
      return false ;
  // Riferimento alla lista dei punti
   const PNTULIST& LoopList = const_cast<PolyLine&>( plPoly).GetUPointList() ;
  // Ciclo sui segmenti della polilinea per cercare il segmento più vicino al punto
   double dMinSqDist = SQ_INFINITO ;
   auto itMinDistEnd = LoopList.end() ;
   auto itStart = LoopList.begin() ;
   auto itEnd = next( itStart) ;
   for ( ; itEnd != LoopList.end() ; ++ itStart, ++ itEnd) {
     // Distanza del punto dal segmento corrente
      DistPointLine dDistCalc( ptP, itStart->first, itEnd->first) ;
      double dSqDist ;
      if ( dDistCalc.GetSqDist( dSqDist)  &&  dSqDist < dMinSqDist) {
         dMinSqDist = dSqDist ;
         itMinDistEnd = itEnd ;
      }
   }
  // Se il punto non sta sulla polilinea, non ha senso spezzare 
   if ( dMinSqDist > dToler * dToler)
      return false ;
  // Copio i punti opportuni nella prima parte
   PNTULIST& LoopList1 = plPoly1.GetUPointList() ;
   for ( auto it = LoopList.begin() ; it != itMinDistEnd ; ++ it)
      LoopList1.emplace_back( it->first, it->second) ;
   plPoly1.AddUPoint( 0, ptP) ;
  // Copio i punti opportuni nella seconda parte
   PNTULIST& LoopList2 = plPoly2.GetUPointList() ;
   for ( auto it = itMinDistEnd ; it != LoopList.end() ; ++ it)
      LoopList2.emplace_back( it->first, it->second) ;
   plPoly2.AddUPoint( 0, ptP, false) ;
   return true ;
}

//----------------------------------------------------------------------------
bool 
AssociatePolyLinesMinDistPoints( const PolyLine& PL1, const PolyLine& PL2, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2, bool& bCommonInternalPoints)
{
  // controllo che le polyline abbiano almeno un punto 
   int nPnt1 = PL1.GetPointNbr() ;
   int nPnt2 = PL2.GetPointNbr() ;
   if ( nPnt1 == 0 || nPnt2 == 0)
      return false ;
 
  // indica la presenza di punti interni in comune tra le due polylines
   bCommonInternalPoints = false ;

   vPnt1.reserve( PL1.GetPointNbr()) ;
   Point3d ptP1 ;
   bool bF1 = PL1.GetFirstPoint( ptP1) ;
   while ( bF1) {
      vPnt1.emplace_back( ptP1, -1) ;
      bF1 = PL1.GetNextPoint( ptP1) ;
   }
   int nTotP1 = int( vPnt1.size()) ;

   vPnt2.reserve( PL2.GetPointNbr()) ;
   Point3d ptP2 ;
   bool bF2 = PL2.GetFirstPoint( ptP2) ;
   while ( bF2) {
      vPnt2.emplace_back( ptP2, -1) ;
      bF2 = PL2.GetNextPoint( ptP2) ;
   }
   int nTotP2 = int( vPnt2.size()) ;

  // calcoli per prima curva
   int nLastJ = 0 ;
   vPnt1[0].second = 0 ;

   for ( int i = 1 ; i < nTotP1 ; ++ i) {

      double dDist = INFINITO ;
      double dMinDistPar = nLastJ ;
      for ( int j = max( nLastJ, 1) ; j < nTotP2 ; ++ j) {
        // distanza del punto dal segmento della polilinea
         DistPointLine PointLineDistCalc( vPnt1[i].first, vPnt2[j-1].first, vPnt2[j].first) ;
         double dPlDist ;         
         if ( PointLineDistCalc.GetDist( dPlDist)  &&  dPlDist < dDist - EPS_SMALL) {
            dDist = dPlDist ;
            PointLineDistCalc.GetParamAtMinDistPoint( dMinDistPar) ;
            dMinDistPar += j - 1 ;
         }
      }
      int nMinJ = ( int)( dMinDistPar + 0.5) ;

      if ( nMinJ < nLastJ)
         nMinJ = nLastJ ;

     // verifica se è un punto interno in comune con l'altra polyline  
      if ( i < nTotP1 - 1  &&  dDist < EPS_SMALL  &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
         bCommonInternalPoints = true ;

      vPnt1[i].second = nMinJ ;
      nLastJ = nMinJ ;
   }

  // calcoli per seconda curva
   int nLastI = 0 ;
   vPnt2[0].second = 0 ;

   for ( int j = 1 ; j < nTotP2 ; ++ j) {

      double dDist = INFINITO ;
      double dMinDistPar = nLastI ;
      for ( int i = max( nLastI, 1) ; i < nTotP1 ; ++ i) {
        // distanza del punto dal segmento della polilinea
         DistPointLine PointLineDistCalc( vPnt2[j].first, vPnt1[i-1].first, vPnt1[i].first) ;
         double dPlDist ;
         if ( PointLineDistCalc.GetDist( dPlDist)  &&  dPlDist < dDist - EPS_SMALL) {
            dDist = dPlDist ;
            PointLineDistCalc.GetParamAtMinDistPoint( dMinDistPar) ;
            dMinDistPar += i - 1 ;
         }
      }
      int nMinI = ( int)( dMinDistPar + 0.5) ;

      if ( nMinI < nLastI)
         nMinI = nLastI ;

      if ( j < nTotP2 - 1  &&  dDist < EPS_SMALL &&  abs( dMinDistPar - floor( dMinDistPar + 0.5)) < EPS_SMALL)
         bCommonInternalPoints = true ;

      vPnt2[j].second = nMinI ;
      nLastI = nMinI ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool 
MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType, PNTIVECTOR& vPnt1, PNTIVECTOR& vPnt2)
{
  // prima trovo le associazioni senza aggiunte di punti
   Point3d ptP2 ;
   CurveComposite cc1, cc2 ;
   cc1.FromPolyLine( PL1) ;
   cc2.FromPolyLine( PL2) ;
   int nPnt1 = PL1.GetPointNbr() ;
   int nPnt2 = PL2.GetPointNbr() ;
   vector<POINTU> vMatch2 ;
   PL2.GetFirstPoint( ptP2) ;
   while ( PL2.GetNextPoint( ptP2, true)) {
      DistPointCurve dpc( ptP2, cc1, false) ;
      int nFlag = 0 ;
      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
      vMatch2.emplace_back( ptJoint, dParam) ;
   }

   int nAtStart2 = 0 ;  // match ripetuti dalla curva U0 allo start della curva U1
   int nAtEnd2 = 0 ;
   Point3d ptP1 ; PL1.GetFirstPoint( ptP1) ;
   int c = 0 ;
   int nRep1 = 0 ;  // match interni consecutivi uguali di punti della curva U0 con punti della curva U1
   int nRep2 = 0 ;
   double dLastParamMatch = 0 ;
   Point3d ptLastPointMatch = ptP1 ;
   BOOLVECTOR vbRep1( nPnt1) ;
   INTVECTOR vnAddedOrNextIsRep1 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
   DBLVECTOR vdSplit1 ;
   DBLVECTOR vdMatch1 ;
   fill( vbRep1.begin(), vbRep1.end(), false) ;
   while ( PL1.GetNextPoint( ptP1, true)) {
      // devo salvarmi se matcho più punti con lo start o l'end della curva totale
      DistPointCurve dpc( ptP1, cc2, false) ;
      int nFlag = 0 ;
      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
      vdMatch1.push_back( dParam) ;
      if ( dParam < EPS_SMALL ) {
         ++nAtStart2 ;
         vbRep1[c] = true ;
         ++c ;
         continue ;
      }
      else if ( dParam > nPnt2 - EPS_SMALL ) {
         vbRep1[c] = nAtEnd2 == 0 ? false : true ;
         vbRep1.back() = true ;
         ++ nAtEnd2 ;
         ++c ;
         continue ;
      }
      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
         dParam = dLastParamMatch ;
         vbRep1[c] = true ;
         ++ nRep1 ;
         ++c ;
         continue ;
      }
      else {
         dLastParamMatch = dParam ;
         ptLastPointMatch = ptJoint ;
         // se sono già troppo vicino ad un split esistente allora non faccio nulla
         if ( abs(dParam - round( dParam)) < 100 * EPS_PARAM) {
            ++c ;
            continue ;
         }
         vdSplit1.push_back( dParam) ;
         // verifico se ho un match per questo punto
         // in tal caso vuol dire che sto creando una ripetizione nRep1
         int nCase = 0 ;
         for ( int j = 0 ; j < int( vMatch2.size()) ; ++j) {
            if ( abs(vMatch2[j].second - (c + 1)) < EPS_SMALL) {
               // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
               bool bFoundMatch = false ;
               for ( int z = int( vMatch2[j].second) ; z < int( vdMatch1.size()) ; ++z) {
                  if ( abs( vdMatch1[z] - ( j + 1 )) < EPS_SMALL ) {
                     bFoundMatch = true ;
                     break ;
                  }
               }

               if ( ! bFoundMatch) {
                  ++ nRep2 ;
                  // capisco se il punto è rep o se lo è il suo successivo
                  if ( j + 1 < dParam)
                     nCase = 1 ;
                  else
                     nCase = 2 ;
               }
               break ;
            }
         }
         vnAddedOrNextIsRep1.push_back( nCase) ;
      }
      ++c ;
   }
   int nAtStart1 = 0 ;
   int nAtEnd1 = 0 ;
   PL2.GetFirstPoint( ptP2) ;
   c = 0 ;
   dLastParamMatch = 0 ;
   ptLastPointMatch = ptP2 ;
   INTVECTOR vnAddedOrNextIsRep2 ;  // 0 non Rep, 1 Rep, 2 Next is Rep ;
   DBLVECTOR vdSplit2 ;
   BOOLVECTOR vbRep2( nPnt2) ;
   fill( vbRep2.begin(), vbRep2.end(), false) ;
   while ( PL2.GetNextPoint( ptP2, true)) {
      DistPointCurve dpc( ptP2, cc1, false) ;
      int nFlag = 0 ;
      double dParam ; dpc.GetParamAtMinDistPoint( 0, dParam, nFlag) ;
      Point3d ptJoint ; dpc.GetMinDistPoint( 0, ptJoint, nFlag) ;
      if ( dParam < EPS_SMALL ) {
         ++nAtStart1 ;
         vbRep2[c] = true ;
         ++c ;
         continue ;
      }
      else if ( dParam > nPnt1 - EPS_SMALL ) {
         vbRep2[c] = ( nAtEnd1 == 0 ? false : true) ;
         vbRep2.back() = true ;
         ++ nAtEnd1 ;
         ++c ;
         continue ;
      }
      if ( dParam <= dLastParamMatch  ||  AreSamePointApprox( ptJoint, ptLastPointMatch)) {
         dParam = dLastParamMatch ;
         vbRep2[c] = true ;
         ++ nRep2 ;
         ++c ;
         continue ;
      }
      else {
         dLastParamMatch = dParam ;
         ptLastPointMatch = ptJoint ;
        // se sono troppo vicino ad uno split esistente allora non faccio nulla
         if ( abs( dParam - round( dParam)) < 100 * EPS_PARAM) {
            ++c ;
            continue ;
         }
         vdSplit2.push_back( dParam) ;
        // verifico se ho un match per questo punto
        // in tal caso vuol dire che sto creando una ripetizione nRep0
         int nCase = 0 ;
         for ( int j = 0 ; j < int( vdMatch1.size()) ; ++j) {
            if ( abs( vdMatch1[j] - (c + 1)) < EPS_SMALL) {
              // devo però verificare che non ci sia un match successivo, perché in quel caso non ho una ripetizione
               bool bFoundMatch = false ;
               for ( int z = int( vdMatch1[j]) ; z < int( vMatch2.size()) ; ++z) {
                  if ( abs( vMatch2[z].second - ( j + 1 )) < EPS_SMALL) {
                     bFoundMatch = true ;
                     break ;
                  }
               }

               if ( ! bFoundMatch) {
                  ++nRep1 ;
                 // capisco se il punto è rep o se lo è il suo successivo
                  if ( j + 1 < dParam)
                     nCase = 1 ;
                  else
                     nCase = 2 ;
               }
               break ;
            }
         }
         vnAddedOrNextIsRep2.push_back( nCase) ;
      }
      ++c ;
   }

  // applico effettivamente gli split e aggiungo gli elementi ai vettori vbRep
   int nUnit = 0 ;
   if ( ! vdSplit1.empty())
      nUnit = int( vdSplit1.back()) ;
   for ( int z = int( vdSplit1.size()) - 1 ; z >= 0 ; --z) {
      double dSplit = vdSplit1[z] ;
      int nSplit = int( dSplit) ;
     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
     // riscalare
      if ( nSplit == nUnit  &&  z < int( vdSplit1.size()) - 1) {
         dSplit = nSplit + ( dSplit - nSplit) / ( vdSplit1[z+1] - nSplit) ;
      }
      nUnit = nSplit ;
      cc2.AddJoint( dSplit) ;
      switch ( vnAddedOrNextIsRep1[z]) {
      case 0 :
         if ( vbRep2[nSplit])
            ++ nRep2 ;
        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
         vbRep2.insert( vbRep2.begin() + nSplit, vbRep2[nSplit]) ;
         break ;
      case 1 :
         vbRep2.insert( vbRep2.begin() + nSplit, true) ;
         break ;
      case 2 :
         if ( vbRep2[nSplit])
            --nRep2 ;
         else
            vbRep2[nSplit] = true ;
         vbRep2.insert( vbRep2.begin() + nSplit, false) ;
         break ;
      }
   }
   if ( ! vdSplit2.empty())
      nUnit = int( vdSplit2.back()) ;
   for ( int z = int( vdSplit2.size()) - 1 ; z >= 0 ; --z) {
      double dSplit = vdSplit2[z] ;
      int nSplit = int( dSplit) ;
     // se sto cercando di fare uno split sulla stessa curva che ho già splittato al passaggio precedente allora devo
     // riscalare
      if ( nSplit == nUnit  &&  z < int( vdSplit2.size()) - 1) {
         dSplit = nSplit + ( dSplit - nSplit) / (vdSplit2[z+1] - nSplit) ;
      }
      nUnit = nSplit ;
      cc1.AddJoint( dSplit) ;
      switch ( vnAddedOrNextIsRep2[z]) {
      case 0 :
         if ( vbRep1[nSplit])
            ++ nRep1 ;
        // di default aggiungerei false, ma se il successivo è già un Rep allora anche questo deve esserlo
         vbRep1.insert( vbRep1.begin() + nSplit, vbRep1[nSplit]) ;
         break ;
      case 1 :
         vbRep1.insert( vbRep1.begin() + nSplit, true) ;
         break ;
      case 2 :
         if ( vbRep1[nSplit])
            -- nRep1 ;
         else
            vbRep1[nSplit] = true ;
         vbRep1.insert( vbRep1.begin() + nSplit, false) ;
         break ;
      }
   }

   nPnt1 = cc1.GetCurveCount() ;
   nPnt2 = cc2.GetCurveCount() ;
   //aggiusto i vettori delle ripetizioni in modo in modo che non arrivino mai ad essere contemporaneamente true
   int nAddedSpan = 0 ;
   int nCrv1 = 0 ;
   int nCrv2 = 0 ;
   while ( nAddedSpan < nPnt1 + nAtStart1 + nAtEnd1 + nRep2) {
      if ( nCrv1 >= nPnt1)
         nCrv1 = nPnt1 - 1 ;
      if ( nCrv2 >= nPnt2)
         nCrv2 = nPnt2 - 1 ;
      bool bRep1 = vbRep1[nCrv1] ;
      bool bRep2 = vbRep2[nCrv2] ;
      if ( bRep1  &&  bRep2) {
         vbRep1[nCrv1] = false ;
         bRep1 = false ;
         vbRep2[nCrv2] = false ;
         bRep2 = false ;
         -- nRep1 ;
         -- nRep2 ;
      }
      if ( ! bRep1  ||  nCrv2 == nPnt2 - 1)
         ++ nCrv2 ;
      if ( ! bRep2  ||  nCrv1 == nPnt1 - 1)
         ++ nCrv1 ;
      ++ nAddedSpan ;
   }
  // se non sono arrivato all'ultima curva su U0 o U1 vuol dire che ho creato delle ripetizioni che non ho contato prima
   if ( nCrv2 < nPnt2) {
      nRep2 += nPnt2 - nCrv2 ;
      for ( int z = int( vbRep2.size()) - 1 ; z >= nCrv2 ; --z)
         vbRep2[z] = true ;
   }
   if ( nCrv1 < nPnt1) {
      nRep1 += nPnt1 - nCrv1 ;
      for ( int z = int( vbRep1.size()) - 1 ; z >= nCrv1 ; --z)
         vbRep1[z] = true ;
   }

  // trovo il numero di span che dovrà avere la superficie
  // ( numero di sottocurve che compongono la U0 + tutte le ripetizioni dei match di punti della curva U1 con i punti di U0)
   int nPnt = nPnt1 + nAtStart1 + nAtEnd1 + nRep2 ;

   if ( nPnt != nPnt2 + nAtStart2 + nAtEnd2 + nRep1)
      LOG_DBG_ERR( GetEGkLogger(), "There could be an error in the creation of a ruled surface in mode RLT_B_MINDIST_PLUS") ;

  // aggiungo i punti di controllo scorrendo in contemporanea le due curve
   nAddedSpan = 0 ;
   nCrv1 = 0 ;
   nCrv2 = 0 ;
   while ( nAddedSpan < nPnt) {
      if ( nCrv1 >= nPnt1)
         nCrv1 = nPnt1 - 1 ;
      if ( nCrv2 >= nPnt2)
         nCrv2 = nPnt2 - 1 ;
      bool bRep1 = vbRep1[nCrv1] ;
      bool bRep2 = vbRep2[nCrv2] ;
      const ICurve* pSubCrv1 = cc1.GetCurve( nCrv1) ;
      Point3d ptStart1 ; pSubCrv1->GetStartPoint( ptStart1) ;
      vPnt1.emplace_back( ptStart1, nAddedSpan) ;
      const ICurve* pSubCrv2 = cc2.GetCurve( nCrv2) ;
      Point3d ptStart2 ; pSubCrv2->GetStartPoint( ptStart2) ;
      vPnt2.emplace_back( ptStart2, nAddedSpan) ;
      if ( ! bRep2)
         ++ nCrv1 ;
      if ( ! bRep1)
         ++ nCrv2 ;
      ++ nAddedSpan ;
   }

   return true ;
}