//----------------------------------------------------------------------------
//  EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : SurfFinishing.cpp       Data : 28.05.19          Versione : 2.1e5
// Contenuto : Implementazione gestione finitura superfici.
//
//
//
// Modifiche : 28.05.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "SurfFinishing.h"
#include "OperationConst.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EXeCmdLogOff.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkOffsetCurve.h"
#include "/EgtDev/Include/EGkIntersCurves.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkCAvToolSurfTm.h"
#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkDistPointSurfFr.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include <thread>
#include <future>
// per far dimenticare macro di WinUser.h
#undef GetClassName

using namespace std ;

//------------------------------ Errors --------------------------------------
// 3101 = "Error in SurfFinishing : UpdateToolData failed"
// 3102 = "Error in SurfFinishing : Tool loading failed"
// 3103 = "Error in SurfFinishing : Chaining failed"
// 3104 = "Error in SurfFinishing : Open Contour"
// 3105 = "Error in SurfFinishing : Contour Not Flat"
// 3106 = "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area"
// 3107 = "Error in SurfFinishing : Empty RawBox"
// 3108 = "Error in SurfFinishing : Depth not computable"
// 3109 = "Error in SurfFinishing : Offset not computable"
// 3110 = "Error in SurfFinishing : Toolpath not computable"
// 3111 = "Error in SurfFinishing : Approach not computable"
// 3112 = "Error in SurfFinishing : Link not computable"
// 3113 = "Error in SurfFinishing : LeadIn not computable"
// 3114 = "Error in SurfFinishing : LeadOut not computable"
// 3115 = "Error in SurfFinishing : Retract not computable"
// 3116 = "Error in SurfFinishing : axes values not calculable"
// 3117 = "Error in SurfFinishing : outstroke xx"
// 3118 = "Error in SurfFinishing : link movements not calculable"
// 3119 = "Error in SurfFinishing : link outstroke"
// 3120 = "Error in SurfFinishing : post apply not calculable"
// 3121 = "Error in SurfFinishing : Linear Approx not computable"
// 3122 = "Error in SurfFinishing : aggregate from bottom not allowed"
// 3123 = "Error in SurfFinishing : missing surfaces"
// 3124 = "Error in SurfFinishing : region not computable"
// 3125 = "Error in SurfFinishing : CalcPocketing failed"
// 3126 = "Error in SurfFinishing : Computing ZConst Curves failed"
// 3127 = "Error in SurfFinishing : Computing ZConst Paths failed"
// 3128 = "Error in SurfFinishing : Curves with different extrusion"
// 3129 = "Error in SurfFinishing : Splitting surfaces failed"
// 3130 = "Error in SurfFinishing : Computing tool region failed"
// 3151 = "Warning in SurfFinishing : Skipped entity (xx)"
// 3152 = "Warning in SurfFinishing : No machinable path"
// 3153 = "Warning in SurfFinishing : Tool name changed (xx)"
// 3154 = "Warning in SurfFinishing : Tool data changed (xx)"

//----------------------------------------------------------------------------
static string KEY_THICK = "THICK" ;
const double SILH_SAMPLING = 1. ;

#define ENABLE_ZCONST_DEBUG 0
#define ENABLE_OPTIMAL_DEBUG 0
#define ENABLE_OPTIMAL_SOFT_DEBUG 0
#if ENABLE_ZCONST_DEBUG || ENABLE_OPTIMAL_DEBUG || ENABLE_OPTIMAL_SOFT_DEBUG
   #include "EgtDev/Include/EGkGeoPoint3d.h"
   #include "EgtDev/Include/EGkGeoVector3d.h"
#endif

//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_SURFFINISHING), SurfFinishing) ;

//----------------------------------------------------------------------------
const string&
SurfFinishing::GetClassName( void) const
{
   return USEROBJ_GETNAME( SurfFinishing) ;
}

//----------------------------------------------------------------------------
SurfFinishing*
SurfFinishing::Clone( void) const
{
  // alloco oggetto
   SurfFinishing* pSrF = new(nothrow) SurfFinishing ;
  // eseguo copia dei dati
   if ( pSrF != nullptr) {
      try {
         pSrF->m_vId = m_vId ;
         pSrF->m_pMchMgr = m_pMchMgr ;
         pSrF->m_nPhase = m_nPhase ;
         pSrF->m_Params = m_Params ;
         pSrF->m_TParams = m_TParams ;
         pSrF->m_dTHoldBase = m_dTHoldBase ;
         pSrF->m_dTHoldLen = m_dTHoldLen ;
         pSrF->m_dTHoldDiam = m_dTHoldDiam ;
         pSrF->m_nStatus = m_nStatus ;
         pSrF->m_nPaths = m_nPaths ;
      }
      catch( ...) {
         delete pSrF ;
         return nullptr ;
      }
   }
  // ritorno l'oggetto
   return pSrF ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Dump( string& sOut, bool bMM, const char* szNewLine) const
{
   sOut += GetClassName() + "[mm]" + szNewLine ;
   sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ;
   sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ;
   for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
      sOut += m_Params.ToString( i) + szNewLine ;
   for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
      sOut += m_TParams.ToString( i) + szNewLine ;
   sOut += KEY_NUM + EQUAL + ToString( m_nPaths) + szNewLine ;
   sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Save( int nBaseId, STRVECTOR& vString) const
{
   try {
      int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ;
      vString.insert( vString.begin(), nSize, "") ;
      int k = - 1 ;
      if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
         return false ;
      for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
         vString[++k] = m_Params.ToString( i) ;
      for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
         vString[++k] = m_TParams.ToString( i) ;
      if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
         return false ;
      if ( ! SetVal( KEY_NUM, m_nPaths, vString[++k]))
         return false ;
      if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
         return false ;
   }
   catch( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Load( const STRVECTOR& vString, int nBaseGdbId)
{
   int nSize = int( vString.size()) ;
  // lista identificativi geometrie da lavorare
   int k = - 1 ;
   if ( k >= nSize - 1  ||  ! GetVal( vString[++k], KEY_IDS, m_vId))
      return false ;
   for ( auto& Sel : m_vId)
      Sel.nId += nBaseGdbId ;
  // parametri lavorazione
   for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) {
      int nKey ;
      if ( k >= nSize - 1  ||  ! m_Params.FromString( vString[++k], nKey)  ||  nKey != i) {
         if ( m_Params.IsOptional( i))
            -- k ;
         else
            return false ;
      }
   }
  // parametri utensile
   for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
      int nKey ;
      if ( k >= nSize - 1  ||  ! m_TParams.FromString( vString[++k], nKey)  ||  nKey != i)
         return false ;
   }
  // parametri di stato
   while ( k < nSize - 1) {
     // separo chiave da valore
      string sKey, sVal ;
      SplitFirst( vString[++k], "=", sKey, sVal) ;
     // leggo
      if ( sKey == KEY_PHASE) {
         if ( ! FromString( sVal, m_nPhase))
            return false ;
      }
      else if ( sKey == KEY_NUM) {
         if ( ! FromString( sVal, m_nPaths))
            return false ;
      }
      else if ( sKey == KEY_STAT) {
         if ( ! FromString( sVal, m_nStatus))
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
SurfFinishing::SurfFinishing( void)
{
   m_Params.m_sName = "*" ;
   m_Params.m_sToolName = "*" ;
   m_TParams.m_sName = "*" ;
   m_TParams.m_sHead = "*" ;
   m_dTHoldBase = 0 ;
   m_dTHoldLen = 0 ;
   m_dTHoldDiam = 0 ;
   m_nStatus = MCH_ST_TO_VERIFY ;
   m_nPaths = 0 ;
   m_bRunning = false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Prepare( const string& sSawName)
{
  // verifico il gestore lavorazioni
   if ( m_pMchMgr == nullptr)
      return false ;
  // recupero il gestore DB utensili della macchina corrente
   ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
   if ( pTMgr == nullptr)
      return false ;
  // recupero il gestore DB lavorazioni della macchina corrente
   MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ;
   if ( pMMgr == nullptr)
      return false ;
  // ricerca della lavorazione di libreria con il nome indicato
   const SurfFinishingData* pDdata = GetSurfFinishingData( pMMgr->GetMachining( sSawName)) ;
   if ( pDdata == nullptr)
      return false ;
   m_Params = *pDdata ;
  // ricerca dell'utensile usato dalla lavorazione
   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
   if ( pTdata == nullptr)
      return false ;
   m_TParams = *pTdata ;
   m_Params.m_sToolName = m_TParams.m_sName ;
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case MPA_INVERT :
      if ( bVal != m_Params.m_bInvert)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bInvert = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_SUBTYPE :
      if ( ! m_Params.VerifySubType( nVal))
         return false ;
      if ( nVal != m_Params.m_nSubType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nSubType = nVal ;
      return true ;
   case MPA_LEADINTYPE :
      if ( ! m_Params.VerifyLeadInType( nVal))
         return false ;
      if ( nVal != m_Params.m_nLeadInType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nLeadInType = nVal ;
      return true ;
   case MPA_LEADOUTTYPE :
      if ( ! m_Params.VerifyLeadOutType( nVal))
         return false ;
      if ( nVal != m_Params.m_nLeadOutType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nLeadOutType = nVal ;
      return true ;
   case MPA_SCC :
      if ( ! m_Params.VerifySolCh( nVal))
         return false ;
      if ( nVal != m_Params.m_nSolCh)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nSolCh = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_SPEED :
      if ( ! m_TParams.VerifySpeed( dVal))
         return false ;
      if ( AreSameAngValue( dVal, m_TParams.m_dSpeed))
         dVal = 0 ;
      m_Params.m_dSpeed = dVal ;
      return true ;
   case MPA_FEED :
      if ( AreSameLenValue( dVal, m_TParams.m_dFeed))
         dVal = 0 ;
      if ( ! AreSameLenValue( dVal, m_Params.m_dFeed))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dFeed = dVal ;
      return true ;
   case MPA_STARTFEED :
      if ( AreSameLenValue( dVal, m_TParams.m_dStartFeed))
         dVal = 0 ;
      if ( ! AreSameLenValue( dVal, m_Params.m_dStartFeed))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartFeed = dVal ;
      return true ;
   case MPA_ENDFEED :
      if ( AreSameLenValue( dVal, m_TParams.m_dEndFeed))
         dVal = 0 ;
      if ( ! AreSameLenValue( dVal, m_Params.m_dEndFeed))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEndFeed = dVal ;
      return true ;
   case MPA_TIPFEED :
      if ( AreSameLenValue( dVal, m_TParams.m_dTipFeed))
         dVal = 0 ;
      if ( ! AreSameLenValue( dVal, m_Params.m_dTipFeed))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTipFeed = dVal ;
      return true ;
   case MPA_OFFSR :
      if ( AreSameLenValue( dVal, m_TParams.m_dOffsR))
         dVal = UNKNOWN_PAR ;
      if ( ! AreSameLenValue( dVal, m_Params.m_dOffsR))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOffsR = dVal ;
      return true ;
   case MPA_DEPTH: {
      string sVal = ToString( dVal) ;
      if ( sVal != m_Params.m_sDepth)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sDepth = sVal ;
      } return true ;
   case MPA_STARTPOS :
      if ( ! AreSameLenValue( dVal, m_Params.m_dStartPos))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartPos = dVal ;
      return true ;
   case MPA_OVERL :
      if ( ! AreSameLenValue( dVal, m_Params.m_dOverlap))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOverlap = dVal ;
      return true ;
   case MPA_SIDESTEP :
      if ( ! AreSameLenValue( dVal, m_Params.m_dSideStep))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dSideStep = dVal ;
      return true ;
   case MPA_SIDEANGLE :
      if ( abs( dVal - m_Params.m_dSideAngle) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dSideAngle = dVal ;
      return true ;
   case MPA_LITANG :
      if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiTang = dVal ;
      return true ;
   case MPA_LIPERP :
      if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiPerp = dVal ;
      return true ;
   case MPA_LOTANG :
      if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoTang = dVal ;
      return true ;
   case MPA_LOPERP :
      if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoPerp = dVal ;
      return true ;
   case MPA_APPROX :
      if ( abs( dVal - m_Params.m_dApprox) > EPS_SMALL)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dApprox = dVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SetParam( int nType, const string& sVal)
{
   switch ( nType) {
   case MPA_TOOL : {
      const ToolData* pTdata ;
      if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
         return false ;
      if ( ! SameTool( m_TParams, *pTdata))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sToolName = sVal ;
      m_Params.m_ToolUuid = pTdata->m_Uuid ;
      m_TParams = *pTdata ;
      } return true ;
   case MPA_DEPTH_STR :
      if ( sVal != m_Params.m_sDepth)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sDepth = sVal ;
      return true ;
   case MPA_SYSNOTES :
      if ( sVal != m_Params.m_sSysNotes)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sSysNotes = sVal ;
      return true ;
   case MPA_USERNOTES :
      if ( sVal != m_Params.m_sUserNotes)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sUserNotes = sVal ;
      return true ;
   case MPA_INITANGS :
      if ( sVal != m_Params.m_sInitAngs)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sInitAngs = sVal ;
      return true ;
   case MPA_BLOCKEDAXIS :
      if ( sVal != m_Params.m_sBlockedAxis)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sBlockedAxis = sVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SetGeometry( const SELVECTOR& vIds)
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // reset della geometria corrente
   m_vId.clear() ;
  // verifico che gli identificativi rappresentino delle entità ammissibili
   for ( const auto& Id : vIds) {
     // test sull'entità
      int nSubs ;
      if ( ! VerifyGeometry( Id, nSubs)) {
         string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 3151, sInfo) ;
         continue ;
      }
     // posso aggiungere alla lista
      m_vId.emplace_back( Id) ;
   }
  // aggiorno lo stato
   m_nStatus |= MCH_ST_GEO_MODIF ;
  // restituisco presenza geometria da lavorare
   return ( ! m_vId.empty()) ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Preview( bool bRecalc)
{
  // non esiste preview, si fa apply
   return Apply( bRecalc, false) ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Apply( bool bRecalc, bool bPostApply)
{
  // se calcoli già in corso, esco
   if ( m_bRunning) {
      LOG_DBG_INFO( GetEMkLogger(), "SurfFinishing::Apply already running") ;
      return true ;
   }
   m_bRunning = true ;
   bool bOk = MyApply( bRecalc, bPostApply) ;
   m_bRunning = false ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
{
  // reset numero tagli nella lavorazione
   int nCurrPaths = m_nPaths ;
   m_nPaths = 0 ;

  // verifico validità gestore DB geometrico e Id del gruppo
   if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
      return false ;

  // aggiorno dati geometrici dell'utensile
   bool bToolChanged = true ;
   if ( ! UpdateToolData( &bToolChanged)) {
      m_pMchMgr->SetLastError( 3101, "Error in SurfFinishing : UpdateToolData failed") ;
      return false ;
   }

  // non è prevista finitura superficie con aggregato da sotto
   if ( IsAggrBottom( m_TParams.m_sHead)) {
      m_pMchMgr->SetLastError( 3122, "Error in SurfFinishing : aggregate from bottom not allowed") ;
      return false ;
   }

  // verifico se necessario continuare nell'aggiornamento
   if ( ! bRecalc  &&  ! bToolChanged  &&  
        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
     // confermo i percorsi di lavorazione
      m_nPaths = nCurrPaths ;
      string sLog = string( "SurfFinishing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
      LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ;
     // eseguo aggiornamento assi macchina e collegamento con operazione precedente
      if ( ! Update( bPostApply))
         return false ;
      m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
      LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
     // esco con successo
      return true ;
   }
   m_nStatus = MCH_ST_TO_VERIFY ;

  // recupero gruppo per geometria ausiliaria
   int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
   bool bChain = false ;
  // se non c'è, lo aggiungo
   if ( nAuxId == GDB_ID_NULL) {
      nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nAuxId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nAuxId, MCH_AUX) ;
      m_pGeomDB->SetStatus( nAuxId, GDB_ST_OFF) ;
      bChain = true ;
   }
  // altrimenti, se chiesto ricalcolo, lo svuoto
   else if ( bRecalc) {
      m_pGeomDB->EmptyGroup( nAuxId) ;
      bChain = true ;
   }

  // rendo corrente l'utensile usato nella lavorazione
   if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
      m_pMchMgr->SetLastError( 3102, "Error in SurfFinishing : Tool loading failed") ;
      return false ;
   }
  // recupero i dati del portautensile
   int nToolId = m_pMchMgr->GetCalcTool() ;
   m_dTHoldBase = 0 ;
   m_pGeomDB->GetInfo( nToolId, TTH_BASE, m_dTHoldBase) ;
   m_dTHoldLen = 0 ;
   m_pGeomDB->GetInfo( nToolId, TTH_LEN, m_dTHoldLen) ;
   m_dTHoldDiam = 0 ;
   m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;

  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
   if ( bChain  &&  ! Chain( nAuxId)) {
      m_pMchMgr->SetLastError( 3103, "Error in SurfFinishing : Chaining failed") ;
      return false ;
   }

  // recupero gruppo per geometria di lavorazione (Cutter Location)
   int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
  // se non c'è, lo aggiungo
   if ( nClId == GDB_ID_NULL) {
      nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nClId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nClId, MCH_CL) ;
   }
  // altrimenti lo svuoto
   else
      m_pGeomDB->EmptyGroup( nClId) ;

  // lavoro ogni singola regione piana
   if ( m_Params.m_nSubType == SURFFIN_SUB_ZIGZAG  || m_Params.m_nSubType == SURFFIN_SUB_ONEWAY  ||
        m_Params.m_nSubType == SURFFIN_SUB_SPIRALIN  ||  m_Params.m_nSubType == SURFFIN_SUB_SPIRALOUT  ||
        m_Params.m_nSubType == SURFFIN_SUB_Z_CONST  ||  m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL) {
      bool bOk = true ;
      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
      while ( nPathId != GDB_ID_NULL) {
         if ( ! ProcessSfr( nPathId, GDB_ID_NULL, nClId))
            bOk = false ;
         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
      }
      if ( ! bOk)
         return false ;
   }
  // lavoro ogni singola curva composita
   else if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
      bool bOk = true ;
      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
      while ( nPathId != GDB_ID_NULL) {
         if ( ! ProcessCrvCompo( nPathId, GDB_ID_NULL, nClId))
            bOk = false ;
         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
      }
      if ( ! bOk)
         return false ;
   }
   else
      return false ;

  // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
   CalcAndSetBBox( nClId) ;

  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
   if ( ! Update( bPostApply))
      return false ;
  
  // aggiorno stato della lavorazione
   m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
  // dichiaro successiva da aggiornare
   UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;

   LOG_DBG_INFO( GetEMkLogger(), "SurfFinishing apply done") ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Update( bool bPostApply)
{
  // verifico validità gestore DB geometrico e Id del gruppo
   if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
      return false ;

  // se lavorazione vuota, esco
   if ( m_nPaths == 0) {
      m_pMchMgr->SetWarning( 3152, "Warning in SurfFinishing : No machinable path") ;
      return true ;
   }

  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
   RemoveClimbRiseHome() ;

  // imposto eventuale asse bloccato da lavorazione
   SetBlockedRotAxis( m_Params.m_sBlockedAxis) ;

  // calcolo gli assi macchina
   string sHint = ExtractHint( m_Params.m_sUserNotes) ;
   if ( ! m_Params.m_sInitAngs.empty())
      sHint = m_Params.m_sInitAngs ;
   if ( ! CalculateAxesValues( sHint)) {
      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
      if ( sInfo.empty())
         m_pMchMgr->SetLastError( 3116, "Error in SurfFinishing : axes values not calculable") ;
      else
         m_pMchMgr->SetLastError( 3117, "Error in SurfFinishing : outstroke ") ;
      return false ;
   }

  // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
   if ( ! AdjustStartEndMovements()) {
      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
      if ( sInfo.empty())
         m_pMchMgr->SetLastError( 3118, "Error in SurfFinishing : link movements not calculable") ;
      else
         m_pMchMgr->SetLastError( 3119, "Error in SurfFinishing : link outstroke ") ;
      return false ;
   }

  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
   CalcAndSetAxesBBox() ;

  // esecuzione eventuali personalizzazioni
   string sErr ;
   if ( bPostApply  &&  ! PostApply( sErr)) {
      if ( ! IsEmptyOrSpaces( sErr))
         m_pMchMgr->SetLastError( 3120, sErr) ;
      else
         m_pMchMgr->SetLastError( 3120, "Error in SurfFinishing : post apply not calculable") ;
      return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, bool& bVal) const
{
   switch ( nType) {
   case MPA_INVERT :
      bVal = m_Params.m_bInvert ;
      return true ;
   }
   bVal = false ;
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_SURFFINISHING ;
      return true ;
   case MPA_SUBTYPE :
      nVal = m_Params.m_nSubType ;
      return true ;
   case MPA_LEADINTYPE :
      nVal = m_Params.m_nLeadInType ;
      return true ;
   case MPA_LEADOUTTYPE :
      nVal = m_Params.m_nLeadOutType ;
      return true ;
   case MPA_SCC :
      nVal = m_Params.m_nSolCh ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case MPA_SPEED :
      dVal = GetSpeed() ;
      return true ;
   case MPA_FEED :
      dVal = GetFeed() ;
      return true ;
   case MPA_STARTFEED :
      dVal = GetStartFeed() ;
      return true ;
   case MPA_ENDFEED :
      dVal = GetEndFeed() ;
      return true ;
   case MPA_TIPFEED :
      dVal = GetTipFeed() ;
      return true ;
   case MPA_OFFSR :
      dVal =GetOffsR() ;
      return true ;
   case MPA_STARTPOS :
      dVal = m_Params.m_dStartPos ;
      return true ;
   case MPA_OVERL :
      dVal = m_Params.m_dOverlap ;
      return true ;
   case MPA_SIDESTEP :
      dVal = m_Params.m_dSideStep ;
      return true ;
   case MPA_SIDEANGLE :
      dVal = m_Params.m_dSideAngle ;
      return true ;
   case MPA_LITANG :
      dVal = m_Params.m_dLiTang ;
      return true ;
   case MPA_LIPERP :
      dVal = m_Params.m_dLiPerp ;
      return true ;
   case MPA_LOTANG :
      dVal = m_Params.m_dLoTang ;
      return true ;
   case MPA_LOPERP :
      dVal = m_Params.m_dLoPerp ;
      return true ;
   case MPA_APPROX :
      dVal = m_Params.m_dApprox ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetParam( int nType, string& sVal) const
{
   switch ( nType) {
   case MPA_NAME :
      sVal = m_Params.m_sName ;
      return true ;
   case MPA_TOOL :
      sVal = m_Params.m_sToolName ;
      return true ;
   case MPA_DEPTH_STR :
      sVal = m_Params.m_sDepth ;
      return true ;
   case MPA_TUUID :
      sVal = ToString( m_Params.m_ToolUuid) ;
      return true ;
   case MPA_UUID :
      sVal = ToString( m_Params.m_Uuid) ;
      return true ;
   case MPA_SYSNOTES :
      sVal = m_Params.m_sSysNotes ;
      return true ;
   case MPA_USERNOTES :
      sVal = m_Params.m_sUserNotes ;
      return true ;
   case MPA_INITANGS :
      sVal = m_Params.m_sInitAngs ;
      return true ;
   case MPA_BLOCKEDAXIS :
      sVal = m_Params.m_sBlockedAxis ;
      return true ;
   }
   sVal = "" ;
   return false ;
}

//----------------------------------------------------------------------------
const ToolData&
SurfFinishing::GetToolData( void) const
{
   return m_TParams ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::UpdateToolData( bool* pbChanged)
{
  // recupero il gestore DB utensili della macchina corrente
   ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
   if ( pTMgr == nullptr)
      return false ;
  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
   if ( pTdata == nullptr) {
      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
      if ( pTdata == nullptr)
         return false ;
      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
   }
  // salvo posizione TC, testa e uscita originali
   string sOrigTcPos = m_TParams.m_sTcPos ;
   string sOrigHead = m_TParams.m_sHead ;
   int nOrigExit = m_TParams.m_nExit ;
  // verifico se sono diversi (ad esclusione di nome, posizione TC, testa e uscita)
   bool bChanged = ( ! SameTool( m_TParams, *pTdata, false)) ;
  // aggiorno comunque i parametri
   m_TParams = *pTdata ;
  // se definito attrezzaggio, aggiorno i parametri che ne possono derivare
   string sTcPos ; string sHead ; int nExit ;
   if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) {
      if ( sOrigTcPos != sTcPos  ||
           sOrigHead  != sHead  ||
           nOrigExit != nExit)
         bChanged = true ;
      m_TParams.m_sTcPos = sTcPos ;
      m_TParams.m_sHead = sHead ;
      m_TParams.m_nExit = nExit ;
   }
   else {
      if ( sOrigTcPos != pTdata->m_sTcPos  ||
           sOrigHead  != pTdata->m_sHead  ||
           nOrigExit  != pTdata->m_nExit)
         bChanged = true ;
   }
  // eventuali segnalazioni
   if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
      string sInfo = "Warning in SurfFinishing : tool name changed (" +
                     m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
      m_pMchMgr->SetWarning( 3153, sInfo) ;
      m_Params.m_sToolName = m_TParams.m_sName ;
   }
   if ( bChanged) {
      string sInfo = "Warning in SurfFinishing : tool data changed (" +
                     m_Params.m_sToolName + ")" ;
      m_pMchMgr->SetWarning( 3154, sInfo) ;
   }
  // se definito parametro di ritorno, lo assegno
   if ( pbChanged != nullptr)
      *pbChanged = bChanged ;
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetGeometry( SELVECTOR& vIds) const
{
  // restituisco l'elenco delle entità
   vIds = m_vId ;
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const
{
  // compenso il raggio dell'utensile
   ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::VerifyGeometry( SelData Id, int& nSubs)
{
  // ammessi : curve o superfici
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   if ( pGObj == nullptr)
      return false ;
  // se curva
   if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
      const ICurve* pCurve = nullptr ;
      // se direttamente la curva
      if ( Id.nSub == SEL_SUB_ALL) {
         pCurve = ::GetCurve( pGObj) ;
         if ( pCurve != nullptr) {
            if ( pCurve->GetType() == CRV_COMPO)
               nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
            else
               nSubs = 0 ;
         }
      }
      // altrimenti sottocurva di composita
      else {
         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
         if ( pCompo != nullptr)
            pCurve = pCompo->GetCurve( Id.nSub) ;
         nSubs = 0 ;
      }
      return ( pCurve != nullptr) ;
   }
  // se altrimenti è superficie trimesh
   else if ( pGObj->GetType() == SRF_TRIMESH) {
      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
      return ( pSurf != nullptr  &&  pSurf->GetFacetCount() >= 1) ;
   }
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
{
  // ammessi : curve
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   if ( pGObj == nullptr)
      return false ;
  // ne recupero il riferimento globale
   Frame3d frGlob ;
   if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
      return false ;
  // se curva
   if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
      PtrOwner<ICurve> pCurve ;
     // se direttamente curva
      if ( Id.nSub == SEL_SUB_ALL) {
        // recupero la curva
         const ICurve* pOriCurve = ::GetCurve( pGObj) ;
         if ( pOriCurve == nullptr)
            return false ;
        // la duplico
         pCurve.Set( pOriCurve->Clone()) ;
        // se estrusione mancante, imposto default
         Vector3d vtExtr ;
         if ( ! pCurve->GetExtrusion( vtExtr)  ||  vtExtr.IsSmall())
            pCurve->SetExtrusion( Z_AX) ;
      }
     // altrimenti sottocurva di composita
      else {
        // recupero la composita
         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
         if ( pCompo == nullptr)
            return false ;
        // recupero la curva semplice
         const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
         if ( pOriCurve == nullptr)
            return false ;
        // la duplico
         pCurve.Set( pOriCurve->Clone()) ;
        // recupero estrusione e spessore
         Vector3d vtExtr ;
         if ( ! pCompo->GetExtrusion( vtExtr)  ||  vtExtr.IsSmall())
            vtExtr = Z_AX ;
         pCurve->SetExtrusion( vtExtr) ;
         double dThick ;
         if ( pCompo->GetThickness( dThick))
            pCurve->SetThickness( dThick) ;
      }
      if ( IsNull( pCurve))
         return false ;
     // la porto in globale
      pCurve->ToGlob( frGlob) ;
     // la restituisco
      lstPC.emplace_back( Release( pCurve)) ;
      return true ;
   }
  // se altrimenti superficie
   else if ( pGObj->GetType() == SRF_TRIMESH)
      return true ;
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::Chain( int nGrpDestId)
{

  // vettore puntatori alle curve
   ICURVEPOVECTOR vpCrvs ;
   vpCrvs.reserve( m_vId.size()) ;
  // vettore selettori delle curve originali
   SELVECTOR vInds ;
  // recupero tutte le curve e le porto in globale
   for ( const auto& Id : m_vId) {
     // prendo le curve
      ICURVEPLIST lstPC ;
      if ( ! GetCurves( Id, lstPC)) {
         string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 3151, sInfo) ;
      }
      for ( auto pCrv : lstPC) {
         vpCrvs.emplace_back( pCrv) ;
         vInds.emplace_back( Id) ;
      }
   }

  // se finitura a proiezione di curve
   if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
      int nGroupName = -1 ;
      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
        // creo nuovo gruppo
         int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ;
         if ( nPathId == GDB_ID_NULL)
            return false ;
         m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nGroupName)) ;
         m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nGroupName)) ;
        // definisco la curva composita associata
         PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( Release( vpCrvs[i]))) ;
         if ( IsNull( pCrvCompo)  ||  ! pCrvCompo->IsValid())
            return false ;
         int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneCurveComposite( pCrvCompo)) ;
         if ( nNewId == GDB_ID_NULL)
            return false ;
        // memorizzo la Thickness e l'Estrusione nelle Info del gruppo
         double dThick ; pCrvCompo->GetThickness( dThick) ;
         Vector3d vtExtr ; pCrvCompo->GetExtrusion( vtExtr) ;
         m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
         m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
      }
      return true ;
   }

  // preparo i dati per il concatenamento
   Vector3d vtExtr = Z_AX ;
   bool bFirst = true ;
   Point3d ptNear = ORIG ;
   double dToler = 10 * EPS_SMALL ;
   ChainCurves chainC ;
   chainC.Init( true, dToler, int( vpCrvs.size())) ;
   for ( size_t i = 0 ; i < vpCrvs.size() ; ++ i) {
     // recupero la curva e il suo riferimento
      ICurve* pCrv = vpCrvs[i] ;
      if ( pCrv == nullptr)
         continue ;
     // recupero i dati della curva necessari al concatenamento e li assegno
      Point3d ptStart, ptEnd ;
      Vector3d vtStart, vtEnd ;
      if ( ! pCrv->GetStartPoint( ptStart)  ||  ! pCrv->GetStartDir( vtStart)  ||
           ! pCrv->GetEndPoint( ptEnd)  ||  ! pCrv->GetEndDir( vtEnd))
         return false ;
      if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
         return false ;
     // se prima curva, assegno inizio della ricerca
      if ( bFirst) {
         pCrv->GetExtrusion( vtExtr) ;
         ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
         bFirst = false ;
      }
     // altrimenti
      else {
         Vector3d vtTmpExtr ; pCrv->GetExtrusion( vtTmpExtr) ;
         if ( ! AreSameVectorApprox( vtTmpExtr, vtExtr)) {
            m_pMchMgr->SetLastError( 3128, "Error in SurfFinishing : Curves with different extrusion") ;
            return false ;
         }
      }
   }
  // recupero i percorsi concatenati e definisco la regione piana di svuotatura
   SurfFlatRegionByContours SfrByC ;
   INTVECTOR vnId2 ;
   while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
     // creo una curva composita
      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
      if ( IsNull( pCrvCompo))
         return false ;
     // estrusione e spessore
      Vector3d vtExtr = Z_AX ;
      double dThick = 0 ;
     // vettore Id originali
      SELVECTOR vId2 ;
      vId2.reserve( vnId2.size()) ;
     // recupero le curve semplici e le inserisco nella curva composita
      for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
         int nId = abs( vnId2[i]) - 1 ;
         bool bInvert = ( vnId2[i] < 0) ;
         vId2.emplace_back( vInds[nId]) ;
        // recupero la curva
         ICurve* pCrv = vpCrvs[nId] ;
        // se necessario, la inverto
         if ( bInvert)
            pCrv->Invert() ;
        // recupero eventuali estrusione e spessore
         Vector3d vtTemp ;
         if ( pCrv->GetExtrusion( vtTemp)) {
            vtExtr = vtTemp ;
            double dTemp ;
            if ( pCrv->GetThickness( dTemp)  &&  abs( dTemp) > abs( dThick))
               dThick = dTemp ;
         }
        // la aggiungo alla curva composta
         if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
            return false ;
      }
     // se non sono state inserite curve, vado oltre
      if ( pCrvCompo->GetCurveCount() == 0)
         continue ;
     // imposto estrusione e spessore
      pCrvCompo->SetExtrusion( vtExtr) ;
      pCrvCompo->SetThickness( dThick) ;
     // verifico sia piana e se necessario la appiattisco
      PtrOwner<ICurve> pFlatCrv( FlattenCurve( *pCrvCompo, 50 * EPS_SMALL, 50 * EPS_ANG_SMALL, FLTCRV_USE_EXTR)) ;
      if ( IsNull( pFlatCrv)) {
         Plane3d plPlane ;
         if ( ! pCrvCompo->IsFlat( plPlane, true, 50 * EPS_SMALL))
            m_pMchMgr->SetLastError( 2403, "Error in SurfFinishing : Contour Not Flat") ;
         else
            m_pMchMgr->SetLastError( 2404, "Error in SurfFinishing : Tool Not Perpendicular to Flat Area") ;
         return false ;
      }
      pFlatCrv->GetExtrusion( vtExtr) ;
      pCrvCompo->Clear() ;
      pCrvCompo->AddCurve( Release( pFlatCrv)) ;
     // salvo vettore estrusione
      pCrvCompo->SetExtrusion( vtExtr) ;
     // salvo la thickness come seconda temp prop ( la Sfr rimuove la thick delle curve)
      pCrvCompo->SetTempParam( dThick, 1) ;
     // aggiorno il nuovo punto vicino
      pCrvCompo->GetEndPoint( ptNear) ;
     // se utile, approssimo con archi
      if ( ! ApproxWithArcsIfUseful( pCrvCompo))
         return false ;
     // inserisco la curva nella regione piana
      SfrByC.AddCurve( Release( pCrvCompo)) ;
   }

  // scorro le regioni piane ricavate dalle curve
   int nGroupName = -1 ;
   PtrOwner<ISurfFlatRegion> pSfrCurr( SfrByC.GetSurf()) ;
   while ( ! IsNull( pSfrCurr)  &&  pSfrCurr->IsValid()) {
     // la normale del Chunk deve essere coerente con l'estrusione ricavata
      if ( AreOppositeVectorApprox( pSfrCurr->GetNormVersor(), vtExtr))
         pSfrCurr->Invert() ;
     // per ogni Chunk
      for ( int nC = 0 ; nC < pSfrCurr->GetChunkCount() ; ++ nC) {
        // creo nuovo gruppo
         int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ;
         if ( nPathId == GDB_ID_NULL)
            return false ;
         m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nGroupName)) ;
         m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nGroupName)) ;
        // recupero il Chunk corrente
         PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrCurr->CloneChunk( nC)) ;
         if ( IsNull( pSfrChunk)  ||  ! pSfrChunk->IsValid())
            return false ;
         int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneSurfFlatRegion( pSfrChunk)) ;
         if ( nNewId == GDB_ID_NULL)
            return false ;
        // salvo eventuali lati aperti per il Chunk corrente
         for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
           // recupero il Loop
            PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL))) ;
            if ( IsNull( pCrvLoop)  ||  !  pCrvLoop->IsValid())
               return false ;
           // memorizzo le proprietà di lato aperto nelle Info del gruppo
            INTVECTOR vIndOpen ;
            for ( int nU = 0 ; nU < pCrvLoop->GetCurveCount() ; ++ nU) {
               int nTmpProp0 = TEMP_PROP_INVALID ;
               if ( pCrvLoop->GetCurveTempProp( nU, nTmpProp0, 0)  &&  nTmpProp0 == TEMP_PROP_OPEN_EDGE)
                  vIndOpen.emplace_back( nU) ;
            }
           // memorizzo la Thickness e l'Estrusione nelle Info del gruppo
            if ( nL == 0) {
               double dThick = pCrvLoop->GetTempParam( 1) ;
               m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
               m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
            }
         }
      }
     // aggiorno la regione piana con la successiva calcolata
      pSfrCurr.Set( SfrByC.GetSurf()) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::ProcessCrvCompo( int nPathId, int nPvId, int nClId)
{
  // recupero gruppo per geometria temporanea
   const string GRP_TEMP = "Temp" ;
   int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
  // se non c'è, lo aggiungo
   if ( nTempId == GDB_ID_NULL) {
      nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nTempId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
   }
  // altrimenti lo svuoto
   else
      m_pGeomDB->EmptyGroup( nTempId) ;
  // in ogni caso lo dichiaro temporaneo e non visibile
   m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
   m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;

  // recupero la curva composita dal database geometrico
   int nCrvCompoId = m_pGeomDB->GetFirstInGroup( nPathId) ;
   if ( m_pGeomDB->GetGeoType( nCrvCompoId) != CRV_COMPO)
      return false ;

  // copio la curva composits da elaborare
   int nCopyId = m_pGeomDB->CopyGlob( nCrvCompoId, GDB_ID_NULL, nTempId) ;
   if ( nCopyId == GDB_ID_NULL)
      return false ;
   const ICurveComposite* pCrvCompoGDB( GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId))) ;
   if ( ! pCrvCompoGDB->IsValid())
      return false ;

  // recupero estrusione e spessore
   Vector3d vtExtr = Z_AX ;
   if ( m_pGeomDB->ExistsInfo( nCrvCompoId, KEY_EXTR))
      m_pGeomDB->GetInfo( nCrvCompoId, KEY_EXTR, vtExtr) ;
   double dThick = 0. ;
   if ( m_pGeomDB->ExistsInfo( nCrvCompoId, KEY_THICK))
      m_pGeomDB->GetInfo( nCrvCompoId, KEY_THICK, dThick) ;

  // valuto l'espressione dell'affondamento
   ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
   double dDepth ;
   string sMyDepth = m_Params.m_sDepth ;
   if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
      m_pMchMgr->SetLastError( 3108, "Error in SurfFinishing : Depth not computable") ;
      return false ;
   }

  // recupero il box del grezzo in globale
   BBox3d b3Raw ;
   if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dTDiam, b3Raw)  ||  b3Raw.IsEmpty()) {
      m_pMchMgr->SetLastError( 3107, "Error in SurfFinishing : Empty RawBox") ;
      return false ;
   }

  // verifico che la curva sia piana
   Plane3d plPlane ;
   if ( ! pCrvCompoGDB->IsFlat( plPlane)) {
      m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
      return false ;
   }

  // recupero nome del path
   string sPathName ;
   m_pGeomDB->GetName( nPathId, sPathName) ;

  // assegno il versore fresa
   Vector3d vtTool = vtExtr ;

   // se richiesta lavorazione
   if ( nClId != GDB_ID_NULL) {
     // creo gruppo per geometria di lavorazione del percorso
      int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
      if ( nPxId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nPxId, sPathName) ;
      m_pGeomDB->SetMaterial( nPxId, BLUE) ;

     // verifico se archi vanno approssimati con segmenti di retta
      bool bSplitArcs = GetSplitArcs( vtTool) ;

     // porto tutte le superfici nel riferimento della prima
      Frame3d frSurf ;
      SURFLOCALVECTOR vSrfLoc ;
      INTVECTOR vSurfId ;
      GetActiveSurfaces( vSurfId) ;
      for ( auto nSurfId : vSurfId) {
         if ( vSrfLoc.empty()) {
            if ( ! m_pGeomDB->GetGlobFrame( nSurfId, frSurf))
               return false ;
         }
         vSrfLoc.emplace_back( m_pGeomDB, nSurfId, frSurf) ;
      }
      if ( ! frSurf.IsValid()) {
         m_pMchMgr->SetLastError( 3123, "Error in SurfFinishing : missing surfaces") ;
         return false ;
      }

     // predispongo l'ambiente di correzione dei percorsi utensili con le superfici attive dei pezzi
      PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
      if ( IsNull( pCAvTlStm))
         return false ;
      if ( abs( m_TParams.m_dSideAng) < EPS_ANG_SMALL) {
         pCAvTlStm->SetStdTool( m_TParams.m_dLen + GetOffsR(),
                                m_TParams.m_dDiam / 2 + GetOffsR(),
                                m_TParams.m_dCornRad + GetOffsR()) ;
      }
      else {
         double dDeltaRad ;
         double dSideAngRad = m_TParams.m_dSideAng * DEGTORAD ;
         if ( m_TParams.m_dSideAng > 0) {
            if ( m_TParams.m_dCornRad < EPS_SMALL)
               dDeltaRad = m_TParams.m_dMaxMat * tan( dSideAngRad) ;
            else
               dDeltaRad = m_TParams.m_dCornRad * cos( dSideAngRad) +
                           ( m_TParams.m_dMaxMat + m_TParams.m_dCornRad * ( sin( dSideAngRad) - 1)) * tan( dSideAngRad) ;
         }
         else {
            dDeltaRad = tan( dSideAngRad) * m_TParams.m_dMaxMat ;
         }
         double dStemRad = m_TParams.m_dDiam / 2 + dDeltaRad ;
         double dTipRad = m_TParams.m_dDiam / 2 ;
         pCAvTlStm->SetAdvTool( m_TParams.m_dLen + GetOffsR(),
                                dStemRad + GetOffsR(),
                                m_TParams.m_dMaxMat,
                                dTipRad + GetOffsR(),
                                m_TParams.m_dCornRad + GetOffsR()) ;
      }
      pCAvTlStm->SetSurfTm( *GetSurfTriMesh( vSrfLoc[0].Get())) ;
      for ( int i = 1 ; i < int( vSrfLoc.size()) ; ++ i)
         pCAvTlStm->AddSurfTm( *GetSurfTriMesh( vSrfLoc[i].Get())) ;

     // assegno il vettore estrazione al gruppo del percorso
      m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;

     // Imposto dati comuni
      SetPathId( nPxId) ;
      SetToolDir( vtTool) ;

     // recupero la curva da lavorare
      PtrOwner<ICurveComposite> pCrvCompo( pCrvCompoGDB->Clone()) ;
      if ( IsNull( pCrvCompo)  ||  ! pCrvCompo->IsValid())
         return false ;

     // Eseguo la lavorazione a seconda del tipo
      double dElev = dDepth ;

      switch ( m_Params.m_nSubType) {
      case SURFFIN_SUB_PROJECT :
         if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompoGDB, vtTool, dDepth, dElev, bSplitArcs))
            return false ;
      break ;
      }
   }

  // incremento numero di percorsi
   ++ m_nPaths ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
{
  // recupero gruppo per geometria temporanea
   const string GRP_TEMP = "Temp" ;
   int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
  // se non c'è, lo aggiungo
   if ( nTempId == GDB_ID_NULL) {
      nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nTempId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nTempId, GRP_TEMP) ;
   }
  // altrimenti lo svuoto
   else
      m_pGeomDB->EmptyGroup( nTempId) ;
  // in ogni caso lo dichiaro temporaneo e non visibile
   m_pGeomDB->SetLevel( nTempId, GDB_LV_TEMP) ;
   m_pGeomDB->SetStatus( nTempId, GDB_ST_OFF) ;

  // recupero la regione piana dal database geometrico
   int nSfrId = m_pGeomDB->GetFirstInGroup( nPathId) ;
   if ( m_pGeomDB->GetGeoType( nSfrId) != SRF_FLATRGN)
      return false ;

  // copio la regione piana da elaborare
   int nCopyId = m_pGeomDB->CopyGlob( nSfrId, GDB_ID_NULL, nTempId) ;
   if ( nCopyId == GDB_ID_NULL)
      return false ;
   const ISurfFlatRegion* pSfrGDB( GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
   if ( ! pSfrGDB->IsValid())
      return false ;

  // recupero estrusione e spessore
   Vector3d vtExtr = Z_AX ;
   if ( m_pGeomDB->ExistsInfo( nSfrId, KEY_EXTR))
      m_pGeomDB->GetInfo( nSfrId, KEY_EXTR, vtExtr) ;
   double dThick = 0. ;
   if ( m_pGeomDB->ExistsInfo( nSfrId, KEY_THICK))
      m_pGeomDB->GetInfo( nSfrId, KEY_THICK, dThick) ;

  // valuto l'espressione dell'affondamento
   ExeLuaSetGlobNumVar( "TH", abs( dThick)) ;
   double dDepth ;
   string sMyDepth = m_Params.m_sDepth ;
   if ( ! ExeLuaEvalNumExpr( ToUpper( sMyDepth), &dDepth)) {
      m_pMchMgr->SetLastError( 3108, "Error in SurfFinishing : Depth not computable") ;
      return false ;
   }
  // se spessore positivo, lo sottraggo al risultato
   if ( dThick > 0)
      dDepth -= dThick ;

  // recupero il box del grezzo in globale
   BBox3d b3Raw ;
   if ( ! GetRawGlobBox( m_nPhase, nPathId, 0.5 * m_TParams.m_dTDiam, b3Raw)  ||  b3Raw.IsEmpty()) {
      m_pMchMgr->SetLastError( 3107, "Error in SurfFinishing : Empty RawBox") ;
      return false ;
   }

  // recupero il Loop esterno della regione da svuotatare
   PtrOwner<ICurve> pCrvExt( pSfrGDB->GetLoop( 0, 0)) ;
   if ( IsNull( pCrvExt)  ||  ! pCrvExt->IsValid())
      return false ;

  // verifico sia piana e sistemo senso antiorario visto dalla direzione di estrusione
   Plane3d plPlane ; double dArea ;
   if ( ! pCrvExt->GetArea( plPlane, dArea)) {
      m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
      return false ;
   }
   if ( abs( plPlane.GetVersN() * vtExtr) < cos( 10 * EPS_ANG_SMALL)) {
      m_pMchMgr->SetLastError( 3006, "Error in SurfFinishing : Tool Dir not perpendicular to Flat Area") ;
      return false ;
   }
   if ( plPlane.GetVersN() * vtExtr * dArea < 0)
      pCrvExt->Invert() ;
   if ( plPlane.GetVersN() * vtExtr < 0)
      plPlane.Invert() ;

  // recupero flag per saltare parti a massimo affondamento
   bool bSkipMaxDown = true ;
   GetValInNotes( m_Params.m_sUserNotes, "SkipMaxDown", bSkipMaxDown) ;

  // recupero nome del path
   string sPathName ;
   m_pGeomDB->GetName( nPathId, sPathName) ;

  // assegno il versore fresa
   Vector3d vtTool = vtExtr ;

  // se richiesta lavorazione
   if ( nClId != GDB_ID_NULL) {
     // creo gruppo per geometria di lavorazione del percorso
      int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
      if ( nPxId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nPxId, sPathName) ;
      m_pGeomDB->SetMaterial( nPxId, BLUE) ;

     // verifico se archi vanno approssimati con segmenti di retta
      bool bSplitArcs = GetSplitArcs( vtTool) ;

     // porto tutte le superfici nel riferimento della prima
      Frame3d frSurf ;
      SURFLOCALVECTOR vSrfLoc ;
      INTVECTOR vSurfId ;
      GetActiveSurfaces( vSurfId) ;
      for ( auto nSurfId : vSurfId) {
         if ( vSrfLoc.empty()) {
            if ( ! m_pGeomDB->GetGlobFrame( nSurfId, frSurf))
               return false ;
         }
         vSrfLoc.emplace_back( m_pGeomDB, nSurfId, frSurf) ;
      }
      if ( ! frSurf.IsValid()) {
         m_pMchMgr->SetLastError( 3123, "Error in SurfFinishing : missing surfaces") ;
         return false ;
      }

     // predispongo l'ambiente di correzione dei percorsi utensili con le superfici attive dei pezzi
      PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
      if ( IsNull( pCAvTlStm))
         return false ;
      if ( abs( m_TParams.m_dSideAng) < EPS_ANG_SMALL) {
         pCAvTlStm->SetStdTool( m_TParams.m_dLen + GetOffsR(),
                                m_TParams.m_dDiam / 2 + GetOffsR(),
                                m_TParams.m_dCornRad + GetOffsR()) ;
      }
      else {
         double dDeltaRad ;
         double dSideAngRad = m_TParams.m_dSideAng * DEGTORAD ;
         if ( m_TParams.m_dSideAng > 0) {
            if ( m_TParams.m_dCornRad < EPS_SMALL)
               dDeltaRad = m_TParams.m_dMaxMat * tan( dSideAngRad) ;
            else
               dDeltaRad = m_TParams.m_dCornRad * cos( dSideAngRad) +
                           ( m_TParams.m_dMaxMat + m_TParams.m_dCornRad * ( sin( dSideAngRad) - 1)) * tan( dSideAngRad) ;
         }
         else {
            dDeltaRad = tan( dSideAngRad) * m_TParams.m_dMaxMat ;
         }
         double dStemRad = m_TParams.m_dDiam / 2 + dDeltaRad ;
         double dTipRad = m_TParams.m_dDiam / 2 ;
         pCAvTlStm->SetAdvTool( m_TParams.m_dLen + GetOffsR(),
                                dStemRad + GetOffsR(),
                                m_TParams.m_dMaxMat,
                                dTipRad + GetOffsR(),
                                m_TParams.m_dCornRad + GetOffsR()) ;
      }
      pCAvTlStm->SetSurfTm( *GetSurfTriMesh( vSrfLoc[0].Get())) ;
      for ( int i = 1 ; i < int( vSrfLoc.size()) ; ++ i)
         pCAvTlStm->AddSurfTm( *GetSurfTriMesh( vSrfLoc[i].Get())) ;

     // determino la regione da lavorare
      PtrOwner<ISurfFlatRegion> pSfrCnt( CreateSurfFlatRegion()) ;
      if ( IsNull( pSfrCnt)  ||  ! pSfrCnt->AddExtLoop( *pCrvExt)) {
         m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
         return false ;
      }
      for ( int nL = 1 ; nL < pSfrGDB->GetLoopCount( 0) ; ++ nL) {
        // recupero l'isola
         PtrOwner<ICurve> pCrvIsl( pSfrGDB->GetLoop( 0, nL)) ;
         if ( IsNull( pCrvIsl)  ||  ! pCrvIsl->IsValid()  ||
              ! pSfrCnt->AddIntLoop( Release( pCrvIsl)))
            return false ;
      }

     // se richiesto, elimino le parti al massimo affondamento
      if ( bSkipMaxDown) {
        // calcolo silhouette dell'insieme di superfici
         CISURFTMPVECTOR vpStm ; vpStm.reserve( vSurfId.size()) ;
         for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i)
            vpStm.emplace_back( GetSurfTriMesh( vSrfLoc[i].Get())) ;
         Frame3d frPocket ;
         Point3d ptCen ; pCrvExt->GetCentroid( ptCen) ;
         frPocket.Set( ptCen, vtTool) ;
         frPocket.ToLoc( frSurf) ;
         const double SILH_TOL = 1.0 ;
         PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
         if ( IsNull( pCavParSilh)  ||  ! pCavParSilh->SetData( vpStm, frPocket, SILH_TOL))
            return false ;
         POLYLINEVECTOR vPL ;
         if ( ! pCavParSilh->GetSilhouette( -dDepth, vPL)) {
            m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
            return false ;
         }
        // creo la regione piana dalle PolyLine ricavate dalla Silhouette
         SurfFlatRegionByContours SfrMaker ;
         for ( auto& PL : vPL) {
           // recupero la curva dalla silhouette
            PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
            if ( IsNull( pSilCrv))
               return false ;
            pSilCrv->FromPolyLine( PL) ;
           // approssimo con archi
            const double SILH_ARC_TOL = 0.1 * SILH_TOL ;
            const double SILH_ARC_FEA_MAX = 100. ;
            PolyArc PA ;
            if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
               PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
               if ( ! IsNull( pTempCrv)  &&
                    pTempCrv->FromPolyArc( PA)  &&
                    pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)  &&
                    pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
                  pSilCrv.Set( pTempCrv) ;
            }
           // aggiungo per regione
            if ( ! SfrMaker.AddCurve( Release( pSilCrv))) {
               m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
               return false ;
            }
         }
         PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
         if ( ! IsNull( pSfrSil)) {
            pSfrSil->ToGlob( frSurf) ;
            double dPockRadOffs = m_TParams.m_dDiam - m_Params.m_dSideStep - m_Params.m_dOverlap ;
            pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
           // intersezione tra contorno e regione
            if ( ! pSfrCnt->Intersect( *pSfrSil)) {
              // ricreo la regione originale
               pSfrCnt->Clear() ;
               pSfrCnt->AddExtLoop( *pCrvExt) ;
            }
           // azzero le proprietà delle curve semplici dei contorni delle regioni ( se 1 lato aperto)
            for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
               for ( int nL = 0 ; nL < pSfrCnt->GetLoopCount( nC) ; ++ nL) {
                  for ( int nCrv = 0 ; ; ++ nCrv) {
                     if ( ! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, 0, 0)  ||
                          ! pSfrCnt->SetCurveTempProp( nC, nL, nCrv, 0, 1))
                        break ;
                  }
               }
            }
         }
      }

     // se regione risultante vuota, non devo fare altro
      if ( ! pSfrCnt->IsValid())
         return true ;

     // assegno il vettore estrazione al gruppo del percorso
      m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;

     // Imposto dati comuni
      SetPathId( nPxId) ;
      SetToolDir( vtTool) ;

     // Eseguo la lavorazione a seconda del tipo
      double dElev = dDepth ;

      switch ( m_Params.m_nSubType) {
      case SURFFIN_SUB_ZIGZAG :
         if ( ! AddZigZag( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
            return false ;
         break ;
      case SURFFIN_SUB_ONEWAY :
         if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
            return false ;
         break ;
      case SURFFIN_SUB_SPIRALIN :
         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, true))
            return false ;
         break ;
      case SURFFIN_SUB_SPIRALOUT :
         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, false))
            return false ;
         break ;
      case SURFFIN_SUB_Z_CONST :
         if ( ! AddZConst( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
            return false ;
         break ;
      case SURFFIN_SUB_OPTIMAL :
         if ( ! AddOptimal( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
            return false ;
         break ;
      }
   }

  // incremento numero di percorsi
   ++ m_nPaths ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SimplifyCurve( ICurveComposite* pCompo) const
{
  // controllo dei parametri
   if ( pCompo == nullptr  ||  ! pCompo->IsValid())
      return false ;

  // ricavo il punto iniziale e finale
   Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
   Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;

  // eseguo le modifiche su una copia della curva originale
   PtrOwner<ICurveComposite> pCompoCL( CloneCurveComposite( pCompo)) ;
   if ( IsNull( pCompoCL))
      return false ;

  // merge per uniformità
   bool bOk = pCompoCL->MergeCurves( 200 * EPS_SMALL, 200 * EPS_ANG_SMALL, false) ;
  // rimozione Spikes o Curve Z
   bOk = bOk && pCompoCL->RemoveSmallDefects( 150 * EPS_SMALL, 2 * ANG_TOL_STD_DEG, true) ;
  // interpolazione mediante linee ed archi
   PolyArc PA ;
   bOk = bOk && pCompoCL->ApproxWithArcsEx( 50 * EPS_SMALL, ANG_TOL_STD_DEG, LIN_FEA_STD, PA)  &&
                pCompoCL->Clear() && pCompoCL->FromPolyArc( PA) ;
  // controllo aggiuntivo sui punti iniziali e finali che siano gli stessi
   Point3d ptNewStart, ptNewEnd ;
   bOk = bOk && pCompoCL->GetStartPoint( ptNewStart) && pCompoCL->GetEndPoint( ptNewEnd)  &&
                AreSamePointApprox( ptNewStart, ptStart) && AreSamePointApprox( ptNewEnd, ptEnd) ;

  // controllo che non si siano create auto-intersezioni
   SelfIntersCurve SIC( *pCompoCL) ;
   bOk = bOk && ( SIC.GetCrossIntersCount() == 0) ;

  // se tutto bene, sostiuisco la curva originale con la modificata
   if ( bOk)
      pCompo->CopyFrom( pCompoCL) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetActiveSurfaces( INTVECTOR& vSurfId) const
{
  // pulisco vettore superfici
   vSurfId.clear() ;
  // verifiche
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
      return false ;
  // cerco tra gli oggetti selezionati
   for ( const auto& Id : m_vId) {
      int nEntId = Id.nId ;
      if ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH)
         vSurfId.emplace_back( nEntId) ;
   }
  // se trovate superfici, considero solo queste ed esco
   if ( ! vSurfId.empty())
      return true ;
  // altrimenti considero tutte le superfici dei pezzi nei grezzi attivi della fase
   int nRawId = m_pMchMgr->GetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
      if ( m_pMchMgr->VerifyRawPartPhase(nRawId, m_nPhase)) {
        // ciclo sui pezzi del grezzo
         int nPartId = m_pMchMgr->GetFirstPartInRawPart( nRawId) ;
         while ( nPartId != GDB_ID_NULL) {
           // ciclo sui layer dei pezzi
            int nLayId = m_pGeomDB->GetFirstGroupInGroup( nPartId) ;
            while ( nLayId != GDB_ID_NULL) {
              // ciclo sulle entità del layer
               int nEntId = m_pGeomDB->GetFirstInGroup( nLayId) ;
               while ( nEntId != GDB_ID_NULL) {
                 // se entità superficie e visibile, la aggiungo
                  int nStat ;
                  if ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH  &&
                        m_pGeomDB->GetCalcStatus( nEntId, nStat)  &&  nStat != GDB_ST_OFF)
                     vSurfId.emplace_back( nEntId) ;
                 // passo alla entità successiva
                  nEntId = m_pGeomDB->GetNext( nEntId) ;
               }
               nLayId =m_pGeomDB->GetNextGroup( nLayId) ;
            }
            nPartId = m_pMchMgr->GetNextPartInRawPart( nPartId) ;
         }
      }
      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // calcolo lo zig-zag
   double dPockRad = m_Params.m_dSideStep ;
   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
   ICRVCOMPOPOVECTOR vpCrvs ;
   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
                         POCKET_ZIGZAG, false, false, true, false, P_INVALID, nullptr, true, vpCrvs)) {
      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
      return false ;
   }

  // determino il riferimento di base della svuotatura
   Frame3d frPocket ;
   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
   frPocket.Set( ptCen, vtTool) ;

  // ciclo sulle curve risultanti
   bool bStart = true ;
   double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
      pMCrv->ToLoc( frPocket) ;
     // li correggo per non interferire con le superfici
      if ( pCAvTlStm != nullptr) {
        // approssimo la curva con una polilinea
         PolyLine PL ;
         if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
            return false ;
        // eventuale aggiunta di punti per garantire max distanza
         const double MIN_DIST = 1. ;
         const double MAX_DIST = 50. ;
         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
         if ( ! PL.AdjustForMaxSegmentLen( dDist))
            return false ;
        // porto nel riferimento delle superfici
         PL.LocToLoc( frPocket, frSurf) ;
        // porto i dati geometrici in locale alle superfici
         Vector3d vtAxL = vtTool ;
         vtAxL.ToLoc( frSurf) ;
         Vector3d vtMoveL = vtAxL ;
        // traslo della lunghezza utensile diminuita dell'affondamento
         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
        // eseguo CAv
         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff))
            return false ;
        // contro-traslo della lunghezza utensile
         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
        // riporto la polilinea nel riferimento della curva
         PL.LocToLoc( frSurf, frPocket) ;
        // elimino i punti allineati
         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
        // creo una curva composita a partire dalla polilinea
         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
            return false ;
        // sostituisco la vecchia curva con la nuova
         pMCrv.Set( pCompo) ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
         pCurve->ToGlob( frPocket) ;
        // se prima entità
         if ( i == 0 ) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ;
            pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         if ( pLine == nullptr)
            return false ;
         Point3d ptP3 = pLine->GetEnd() ;
         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
         SetFeed( GetRightFeed( vtMove, vtTool)) ;
         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ;
            pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // aggiungo uscita
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
               return false ;
            }
           // determino elevazione su fine uscita
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
           // se non è ultimo tratto, aggiungo retrazione di collegamento
            if ( k < int( vpCrvs.size()) - 1) {
               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // altrimenti aggiungo retrazione finale
            else {
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // calcolo lo one-way
   double dPockRad = m_Params.m_dSideStep ;
   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
   ICRVCOMPOPOVECTOR vpCrvs ;
   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
                         POCKET_ONEWAY, false, false, true, false, P_INVALID, nullptr, true, vpCrvs)) {
      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
      return false ;
   }

  // determino il riferimento di base della svuotatura
   Frame3d frPocket ;
   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
   frPocket.Set( ptCen, vtTool) ;

  // ciclo sulle curve risultanti
   bool bStart = true ;
   double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
      pMCrv->ToLoc( frPocket) ;
     // li correggo per non interferire con le superfici
      if ( pCAvTlStm != nullptr) {
        // approssimo la curva con una polilinea
         PolyLine PL ;
         if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
            return false ;
        // eventuale aggiunta di punti per garantire max distanza
         const double MIN_DIST = 1. ;
         const double MAX_DIST = 50. ;
         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
         if ( ! PL.AdjustForMaxSegmentLen( dDist))
            return false ;
        // porto nel riferimento delle superfici
         PL.LocToLoc( frPocket, frSurf) ;
        // porto i dati geometrici in locale alle superfici
         Vector3d vtAxL = vtTool ;
         vtAxL.ToLoc( frSurf) ;
         Vector3d vtMoveL = vtAxL ;
        // traslo della lunghezza utensile diminuita dell'affondamento
         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
        // eseguo CAv
         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff))
            return false ;
        // contro-traslo della lunghezza utensile
         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
        // riporto la polilinea nel riferimento della curva
         PL.LocToLoc( frSurf, frPocket) ;
        // elimino i punti allineati
         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
        // creo una curva composita a partire dalla polilinea
         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
            return false ;
        // sostituisco la vecchia curva con la nuova
         pMCrv.Set( pCompo) ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
         pCurve->ToGlob( frPocket) ;
        // se prima entità
         if ( i == 0 ) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ;
            pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         if ( pLine == nullptr)
            return false ;
         Point3d ptP3 = pLine->GetEnd() ;
         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
         SetFeed( GetRightFeed( vtMove, vtTool)) ;
         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ;
            pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // aggiungo uscita
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
               return false ;
            }
           // determino elevazione su fine uscita
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
           // se non è ultimo tratto, aggiungo retrazione di collegamento
            if ( k < int( vpCrvs.size()) - 1) {
               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // altrimenti aggiungo retrazione finale
            else {
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
{  
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // calcolo la spirale
   double dPockRad = m_Params.m_dSideStep ;
   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
   int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ;
   ICRVCOMPOPOVECTOR vpCrvs ;
   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
                         nType, false, false, true, false, P_INVALID, nullptr, true, vpCrvs)) {
      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
      return false ;
   }

  // determino il riferimento di base della svuotatura
   Frame3d frPocket ;
   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
   frPocket.Set( ptCen, vtTool) ;

  // ciclo sulle curve risultanti
   bool bStart = true ;
   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
      pMCrv->ToLoc( frPocket) ;
     // li correggo per non interferire con le superfici
      if ( pCAvTlStm != nullptr) {
        // approssimo la curva con una polilinea
         PolyLine PL ;
         if ( ! pMCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
            return false ;
        // eventuale aggiunta di punti per garantire max distanza
         const double MIN_DIST = 1. ;
         const double MAX_DIST = 50. ;
         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
         if ( ! PL.AdjustForMaxSegmentLen( dDist))
            return false ;
        // porto nel riferimento delle superfici
         PL.LocToLoc( frPocket, frSurf) ;
        // porto i dati geometrici in locale alle superfici
         Vector3d vtAxL = vtTool ;
         vtAxL.ToLoc( frSurf) ;
         Vector3d vtMoveL = vtAxL ;
        // traslo della lunghezza utensile diminuita dell'affondamento
         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
        // eseguo CAv
         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox))
            return false ;
        // contro-traslo della lunghezza utensile
         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
        // riporto la polilinea nel riferimento della curva
         PL.LocToLoc( frSurf, frPocket) ;
        // elimino i punti allineati
         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
        // creo una curva composita a partire dalla polilinea
         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
            return false ;
        // sostituisco la vecchia curva con la nuova
         pMCrv.Set( pCompo) ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
         pCurve->ToGlob( frPocket) ;
        // se prima entità
         if ( i == 0 ) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ;
            pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         if ( pLine == nullptr)
            return false ;
         Point3d ptP3 = pLine->GetEnd() ;
         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
         SetFeed( GetRightFeed( vtMove, vtTool)) ;
         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ;
            pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // aggiungo uscita
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
               return false ;
            }
           // determino elevazione su fine uscita
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
           // se non è ultimo tratto, aggiungo retrazione di collegamento
            if ( false) {
               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // altrimenti aggiungo retrazione finale
            else {
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                                                       const ISurfFlatRegion* pSfr, const Vector3d& vtTool,
                                                       set<double>& setZAmbiguos)
{
  // controllo dei parametri
   setZAmbiguos.clear() ;
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;

  // creo un frame centrato sulla superficie piana
   Frame3d frSfr ;
   Point3d ptC ; pSfr->GetCentroid( ptC) ;
   if ( ! frSfr.Set( ptC, pSfr->GetNormVersor())  ||  ! frSfr.IsValid())
      return false ;
  // porto una copia della superficie in questo frame
   PtrOwner<ISurfFlatRegion> pSfrLoc( CloneSurfFlatRegion( pSfr)) ;
   if ( IsNull( pSfrLoc)  ||  ! pSfrLoc->IsValid()  ||  ! pSfrLoc->ToLoc( frSfr))
      return false ;

  // scorro le superfici trimesh selezionate
   for ( int nS = 0 ; nS < int( vSrfLoc.size()) ; ++ nS) {
     // recupero la superficie
      const ISurfTriMesh* pStm = GetSurfTriMesh( vSrfLoc[nS].Get()) ;
      if ( pStm == nullptr  ||  ! pStm->IsValid())
         continue ;
     // scorro le facce
      for ( int nF = 0 ; nF < pStm->GetFacetCount() ; ++ nF) {
        // recupero il centro e la normale della faccia
         Point3d ptCenter ;
         Vector3d vtNorm ;
         if ( pStm->GetFacetCenter( nF, ptCenter, vtNorm)) {
           // confronto la normale con la direzione dell'utensile
            vtNorm.ToGlob( frSurf) ;
            if ( AreSameVectorEpsilon( vtNorm, vtTool, 10 * EPS_SMALL)) {
              // recupero i contorni della faccia
               POLYLINEVECTOR vPL ;
               if ( pStm->GetFacetLoops( nF, vPL)) {
                 // recupero la superficie piana dalle curve
                  SurfFlatRegionByContours SfrByC ;
                  for ( int nPL = 0 ; nPL < int( vPL.size()) ; ++ nPL) {
                     PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
                     if ( IsNull( pCrvCompo)  ||  ! pCrvCompo->FromPolyLine( vPL[nPL]))
                        return false ;
                    // porto la curva nel riferimento della superficie piana di classificazione
                     pCrvCompo->ToLoc( frSfr) ;
                    // aggiungo la curva alla FlatRegion
                     SfrByC.AddCurve( Release( pCrvCompo)) ;
                  }
                  ptCenter.ToLoc( frSfr) ;
                 // recupero la superficie
                  PtrOwner<ISurfFlatRegion> pSfrFace( SfrByC.GetSurf()) ;
                  if ( IsNull( pSfrFace)  ||  ! pSfrFace->IsValid()) {
                    // in questo caso potrei avere geometrie complesse per le facce della pStm
                    // inserisco la Z del piano locale nell'insieme
                     setZAmbiguos.insert( ptCenter.z) ;
                     continue ;
                  }
                 // se esiste intersezione tra pSfrFace e pSfr allora salvo la Z locale
                  pSfrFace->Intersect( *pSfrLoc) ;
                  if ( ! IsNull( pSfrFace)  &&  pSfrFace->IsValid())
                     setZAmbiguos.insert( ptCenter.z) ;
               }
            }
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
ICAvParSilhouettesSurfTm*
SurfFinishing::GetParSilhouettesForZConst( const ISURFTMPOVECTOR& vStm, const ISurfFlatRegion* pSfr) const
{
  // controllo dei parametri
   if ( vStm.empty()  ||  pSfr == nullptr  ||  ! pSfr->IsValid())
      return nullptr ;

  // inizializzo la classe di calcolo delle silhouette nei piani come sopra
   CISURFTMPVECTOR vpStm ;  vpStm.reserve( vStm.size()) ;
   for ( int i = 0 ; i < int( vStm.size()) ; ++ i)
      vpStm.emplace_back( vStm[i]) ;

   const double SILH_SHARPED_ANG_TOL = ANG_TOL_STD_DEG ;
   PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
   if ( IsNull( pCavParSilh)  ||
        ! pCavParSilh->SetDataForRegion( vpStm, pSfr, m_TParams.m_dSideAng, m_TParams.m_dDiam,
                                         m_TParams.m_dCornRad, m_TParams.m_dMaxMat, GetOffsR(), SILH_SAMPLING, SILH_SHARPED_ANG_TOL))
      return nullptr ;

   return ( Release( pCavParSilh)) ;
}

//----------------------------------------------------------------------------
ISurfFlatRegion*
SurfFinishing::GetSfrSilhouette( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frLvl0, double dDepth) const
{
  // inizializzo vettore di puntatori a superfici costanti
   CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
  // scorro le superfici
   for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
     // recupero la superficie TriMesh
      const ISurfTriMesh* pStm = GetSurfTriMesh( vSrfLoc[i].Get()) ;
     // se valida, la memorizzo
      if ( pStm != nullptr  &&  pStm->IsValid()  &&  pStm->GetTriangleCount() > 0)
         vpStm.emplace_back( pStm) ;
   }

  // inizializzo classe di calcolo della silhouette
   const double SILH_TOL = 1.0 ;
   PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
   if ( IsNull( pCavParSilh)  ||  ! pCavParSilh->SetData( vpStm, frLvl0, SILH_TOL))
      return nullptr ;
  // vettore di PolyLine
   POLYLINEVECTOR vPL ;
   if ( ! pCavParSilh->GetSilhouette( dDepth, vPL))
      return nullptr ;
  // creo la regione piana dalle PolyLine ricavate dalla Silhouette
   SurfFlatRegionByContours SfrMaker ;
   for ( auto& PL : vPL) {
     // recupero la curva dalla silhouette
      PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
      if ( IsNull( pSilCrv))
         return nullptr ;
      pSilCrv->FromPolyLine( PL) ;
     // approssimo con archi
      const double SILH_ARC_TOL = 100 * EPS_SMALL ;
      const double SILH_ARC_FEA_MAX = 100. ;
      PolyArc PA ;
      if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
         PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
         if ( ! IsNull( pTempCrv)  &&
            pTempCrv->FromPolyArc( PA)  &&
            pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)  &&
            pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
          pSilCrv.Set( pTempCrv) ;
      }

     // aggiungo per regione
      if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
         return nullptr ;
   }

   return ( SfrMaker.GetSurf()) ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                                 const ISurfFlatRegion* pSfrClass, const Vector3d& vtTool, double dDepth, vector<ICRVCOMPOPOVECTOR>& vCrvCompo)
{
  /* funzione per calcolare le curve singole di finitura mediante Silhouette e le regioni da non rovinare */

  // controllo che la regione piana sia definita correttamente
   vCrvCompo.clear() ;
   if ( pSfrClass == nullptr  ||  ! pSfrClass->IsValid())
      return false ;

  // NB. Essendo una finitura a Z costante, devo controllare che i piani di finitura non facciano
  //     overlap con facce delle TriMesh selezionate con normale simile a vtTool
   set<double> setZAmbiguos ;
   PtrOwner<ISurfFlatRegion> pSfrZAmb( CloneSurfFlatRegion( pSfrClass)) ;
   if ( IsNull( pSfrZAmb)  ||  ! pSfrZAmb->IsValid()  ||
        ! pSfrZAmb->Offset( m_TParams.m_dDiam / 2. + abs( m_Params.m_dOverlap), ICurve::OFF_FILLET))
      return false ;
   if ( ! GetZConstQuotesInsideSfrParallelToTool( vSrfLoc, frSurf, pSfrZAmb, vtTool, setZAmbiguos))
      return false ;

  // aggiorno la ProgressBar al 40%
   ExeProcessEvents( 40, 0) ;

  // calcolo la silhouette sui diversi piani
   for ( int nPlane = 1 ; nPlane * m_Params.m_dSideStep < dDepth + EPS_SMALL ; ++ nPlane) {
     // riservo lo spazio nel vettore delle curve
      vCrvCompo.resize( vCrvCompo.size() + 1) ;
     // definisco la Zlocale per il calcolo della silhouette
      double dZLoc = - nPlane * m_Params.m_dSideStep ;
      for ( set<double>::iterator it = setZAmbiguos.begin() ; it != setZAmbiguos.end() ; ++ it) {
         if ( abs( *it - dZLoc) < 5 * EPS_SMALL)
            dZLoc += ( nPlane == 1 ? - 10 * EPS_SMALL : + 10 * EPS_SMALL) ;
      }
     // calcolo vettore di PolyLine ottenute al piano corrente
      POLYLINEVECTOR vPL ;
      if ( ! pCavParSilh->GetSilhouetteInsideRegion( dZLoc, vPL))
         return false ;
      for ( auto& PL : vPL) {
        // recupero la curva dalla silhouette
         PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
         if ( IsNull( pSilCrv))
            return false ;
         pSilCrv->FromPolyLine( PL) ;
        // approssimo con archi
         const double SILH_ARC_TOL = 0.1 * SILH_SAMPLING ;
         const double SILH_ARC_FEA_MAX = 100. ;
         PolyArc PA ;
         if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
            PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
            if ( ! IsNull( pTempCrv)  &&
                 pTempCrv->FromPolyArc( PA)  &&
                 pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG)  &&
                 pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
               pSilCrv.Set( pTempCrv) ;
         }
         SimplifyCurve( pSilCrv) ;
         vCrvCompo.back().emplace_back( Release( pSilCrv)) ;
      }
     // controllo validità delle curve
      for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i)
         if ( vCrvCompo.back()[i] == nullptr  ||  ! vCrvCompo.back()[i]->IsValid())
            return false ;
     // preparo i dati per il concatenamento
      bool bFirst = true ;
      Point3d ptNear = ORIG ;
      double dToler = 500 * EPS_SMALL ; 
      ChainCurves chainC ;
      chainC.Init( false, dToler, int( vCrvCompo.back().size())) ;
      for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i) {
        // recupero i dati della curva necessari al concatenamento e li assegno
         Point3d ptStart, ptEnd ;
         Vector3d vtStart, vtEnd ;
         if ( ! vCrvCompo.back()[i]->GetStartPoint( ptStart)  ||  ! vCrvCompo.back()[i]->GetStartDir( vtStart)  ||
              ! vCrvCompo.back()[i]->GetEndPoint( ptEnd)  ||  ! vCrvCompo.back()[i]->GetEndDir( vtEnd))
         return false ;
         if ( ! chainC.AddCurve( int( i + 1), ptStart, vtStart, ptEnd, vtEnd))
            return false ;
        // se prima curva, assegno inizio della ricerca
         if ( bFirst) {
            ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
            bFirst = false ;
         }
      }
     // vettore delle curve composite risultante
      ICRVCOMPOPOVECTOR vCrvCompoChained ;
     // recupero i percorsi concatenati
      INTVECTOR vnInd ;
      while ( chainC.GetChainFromNear( ptNear, true, vnInd)) {
        // creo una curva composita
         PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
         if ( IsNull( pCrvCompo))
            return false ;
        // recupero le curve semplici e le inserisco nella curva composita
         for ( size_t i = 0 ; i < vnInd.size() ; ++ i) {
            int nId = abs( vnInd[i]) - 1 ;
           // la aggiungo alla curva composta
            if ( ! pCrvCompo->AddCurve( CloneCurveComposite( vCrvCompo.back()[nId]), true, dToler))
               return false ;
         }
        // aggiorno il nuovo punto vicino
         if ( pCrvCompo->GetCurveCount() > 0) {
            pCrvCompo->GetEndPoint( ptNear) ;
            vCrvCompoChained.emplace_back( Release( pCrvCompo)) ;
         }
      }
      swap( vCrvCompoChained, vCrvCompo.back()) ;
     // salvo lo Step come primo temp param della curva e inverto se necessario
      for ( int i = 0 ; i < int( vCrvCompo.back().size()) ; ++ i) {
         vCrvCompo.back()[i]->SetTempParam( - nPlane * m_Params.m_dSideStep, 0) ;
         if ( m_Params.m_bInvert)
            vCrvCompo.back()[i]->Invert() ;
      }

     // aggiorno la ProgressBar
      ExeProcessEvents( 40 + int( 40 / ( dDepth / max( 0.1, m_Params.m_dSideStep)) * ( nPlane - 1)), 0) ;
   }

  // controllo la validità di tutte le curve trovate
   for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
      for ( int j = 0 ; j < int( vCrvCompo[i].size()) ; ++ j) {
         if ( vCrvCompo[i][j] == nullptr  ||  ! vCrvCompo[i][j]->IsValid())
            return false ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
                                  vector<ICRVCOMPOPOVECTOR>& vCrvCompo, const Vector3d& vtTool, const ISurfFlatRegion* pSfr,
                                  double dDepth, ICRVCOMPOPOVECTOR& vCrvPath)
{
  /* funzione per collegare le curve trovate creando quindi i percorsi di lavoro */
  // NB. La prima tempProp della curva è il piano in cui iniziale e la seconda tempProp è
  // il piano a cui finisce

  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
   PtrOwner<ISurfFlatRegion> pSfrClass( CloneSurfFlatRegion( pSfr)) ;
   if ( IsNull( pSfrClass)  ||  ! pSfrClass->IsValid())
      return false ;

  // porto il tool nel frame della superficie
   Vector3d vtToolLoc = GetToLoc( vtTool, frSurf) ;

  // porto tutte le curve nel piano XY locale alla pSfr
   Frame3d frXY ;
   Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
   if ( ! frXY.Set( ptCenter, vtToolLoc))
      return false ;
   for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
      for ( int j = 0 ; j < int( vCrvCompo[i].size()) ; ++ j) {
         vCrvCompo[i][j]->ToLoc( frXY) ;
         #if ENABLE_ZCONST_DEBUG
            int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvCompo[i][j]->Clone()) ;
            m_pGeomDB->SetMaterial( _a, OLIVE) ;
         #endif
      }
   }
  // tengo una copia dei bordi della regione
   pSfrClass->ToLoc( frXY) ;
   #if ENABLE_ZCONST_DEBUG
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrClass->Clone()) ;
      m_pGeomDB->SetMaterial( _a, Color( 0., 1., 0., .15)) ;
   #endif
   ICRVCOMPOPOVECTOR vCrvSfrLoops ;
   for ( int nC = 0 ; nC < pSfrClass->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfrClass->GetLoopCount( nC) ; ++ nL) {
         PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrClass->GetLoop( nC, nL))) ;
         if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
            return false ;
        // tutti i loop sono orientati come il loop esterno ( aiuta per la classificazione della curve)
         if ( nL > 0)
            pCrvLoop->Invert() ;
         vCrvSfrLoops.emplace_back( Release( pCrvLoop)) ;
         #if ENABLE_ZCONST_DEBUG
            int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvSfrLoops.back()->Clone()) ;
            m_pGeomDB->SetMaterial( _a, PURPLE) ;
         #endif

      }
   }
  // definisco il piano locale della regione piana
   Plane3d plProjection ;
   if ( ! plProjection.Set( ORIG, Z_AX))
      return false ;

   int nCurrRow = 0 ;
  // scorro le righe
   for ( ; nCurrRow < int( vCrvCompo.size()) - 1 ; ++ nCurrRow) {
     // scorro sulle colonne
      for ( int nCurrCol = 0 ; nCurrCol < int( vCrvCompo[nCurrRow].size()) ; ++ nCurrCol) {
        // se la curva attuale è nulla, passo alla successiva
         if ( vCrvCompo[nCurrRow][nCurrCol] == nullptr)
            continue ;
        // recupero il punto finale della curva corrente
         Point3d ptCurrEnd ; vCrvCompo[nCurrRow][nCurrCol]->GetEndPoint( ptCurrEnd) ;
        // recupero la distanza con la Sfr
         double dSfrDistCurr = vCrvCompo[nCurrRow][nCurrCol]->GetTempParam( 0) ;
        // inizializzo spazio per un nuovo percorso ( inserisco la curva corrente)
         vCrvPath.resize( vCrvPath.size() + 1) ;
         vCrvPath.back().Set( vCrvCompo[nCurrRow][nCurrCol]) ;
        // salvo come prima temp prop il numero del piano a cui sono
         vCrvPath.back()->SetTempProp( nCurrRow + 1, 0) ;
        // scorro sulle righe successive
         for ( int nNextRow = nCurrRow + 1 ; nNextRow < int( vCrvCompo.size()) ; ++ nNextRow) {
           // cerco le curve valide tra le colonne
            double dMinSqDist = INFINITO ; // euristico
            int nNextCol_path = -1 ;
            for ( int nNextCol = 0 ; nNextCol < int( vCrvCompo[nNextRow].size()) ; ++ nNextCol) {
              // se curva già in un Path, cerco la successiva
               if ( vCrvCompo[nNextRow][nNextCol] == nullptr)
                  continue ;
              // se la curva successiva è aperta
               if ( ! vCrvCompo[nNextRow][nNextCol]->IsClosed()) {
                 // controllo la distanza con il punto iniziale della curva
                  Point3d ptS ; vCrvCompo[nNextRow][nNextCol]->GetStartPoint( ptS) ;
                  double dNextSqDist = SqDist( ptS, ptCurrEnd) ;
                  if ( dNextSqDist < dMinSqDist) {
                     dMinSqDist = dNextSqDist ;
                     nNextCol_path = nNextCol ;
                  }
                 // controllo la distanza con il punto finale della curva
                  Point3d ptE ; vCrvCompo[nNextRow][nNextCol]->GetEndPoint( ptE) ;
                  dNextSqDist = SqDist( ptE, ptCurrEnd) ;
                  if ( dNextSqDist < dMinSqDist) {
                     dMinSqDist = dNextSqDist ;
                     nNextCol_path = nNextCol ;
                     vCrvCompo[nNextRow][nNextCol]->Invert() ; // inverto
                  }
               }
              // se la curva successiva è chiusa
               else {
                 // cerco il punto a minima distanza
                  DistPointCurve DistPtCrv( ptCurrEnd, *vCrvCompo[nNextRow][nNextCol]) ;
                  double dNextSqDist = 0. ;
                  if ( DistPtCrv.GetSqDist( dNextSqDist)) {
                     if ( dNextSqDist < dMinSqDist) {
                        dMinSqDist = dNextSqDist ;
                        nNextCol_path = nNextCol ;
                        double dMinPar = 0. ;
                        int nFlag = 0 ;
                        if ( DistPtCrv.GetParamAtMinDistPoint( 0., dMinPar, nFlag))
                           vCrvCompo[nNextRow][nNextCol]->ChangeStartPoint( dMinPar) ;
                     }
                  }
               }
            }
           // se non ho trovato nessuna colonna valida
            if ( nNextCol_path == -1) {
               nCurrRow = 0 ; // azzero il contatore delle righe
               break ; // interrompo ciclo sulle righe successive di ricerca
            }
           // altrimenti creo raccordo e aggiungo la curva al percorso
            else {
              // definisco un tratto lineare che collega gli estremi
               Point3d ptStartLink = ptCurrEnd ;
               Point3d ptEndLink ; vCrvCompo[nNextRow][nNextCol_path]->GetStartPoint( ptEndLink) ;
               PtrOwner<ICurveLine> pLineLink( CreateCurveLine()) ;
               if ( IsNull( pLineLink)  ||  ! pLineLink->Set( ptStartLink, ptEndLink)  ||
                    ! pLineLink->IsValid()) {
                 // se tratto lineare non valido, non creo il collegamento
                  nCurrRow = 0 ; // azzero il contatore delle righe
                  break ; // interrompo ciclo sulle righe successive di ricerca
               }
              // se la linea è parallela a vtTool( Z_AX), allora ho una parete verticale (localmente)
               Vector3d vtLineLink ; pLineLink->GetStartDir( vtLineLink) ;
               if ( AreSameOrOppositeVectorEpsilon( vtLineLink, Z_AX, 100 * EPS_SMALL)) {
                 // in questo caso la proiezione del link è automaticamente sul bordo della pSrfClass
                  vCrvPath.back()->AddCurve( Release( pLineLink), true, 1500 * EPS_SMALL) ;
                  vCrvPath.back()->AddCurve( Release( vCrvCompo[nNextRow][nNextCol_path]), true, 1500 * EPS_SMALL) ;
               }
               else {
                 // altrimenti, se i punti sono distanti, allora non considero valido il collegamento
                  if ( SqDist( ptStartLink, ptEndLink) > m_TParams.m_dDiam * 2) {
                     nCurrRow = 0 ; // azzero il contatore delle righe
                     break ; // interrompo ciclo sulle righe successive di ricerca
                  }

                  #if ENABLE_ZCONST_DEBUG
                     int _b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pLineLink->Clone()) ;
                     m_pGeomDB->SetMaterial( _b, ORANGE) ;
                  #endif

                 // proietto la curva nel piano locale della pSfrClass ( Z=0 ; Z_AX)
                  PtrOwner<ICurve> pLineLinkProjected( ProjectCurveOnPlane( *pLineLink, plProjection)) ;
                  if ( IsNull( pLineLinkProjected)  ||  ! pLineLinkProjected->IsValid())
                     return false ;

                  #if ENABLE_ZCONST_DEBUG
                     int _c = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pLineLinkProjected->Clone()) ;
                     m_pGeomDB->SetMaterial( _c, YELLOW) ;
                  #endif

                 // classifico la curva proiettata in base alla superficie
                  CRVCVECTOR ccClass ;
                  if ( ! pSfrClass->GetCurveClassification( *pLineLinkProjected, EPS_SMALL, ccClass))
                     return false ;
                 // inizializzo la nuova curva di Link
                  PtrOwner<ICurveComposite> pCompoLink( CreateCurveComposite()) ;
                  if ( IsNull( pCompoLink))
                     return false ;
                 // scorro sulle classificazioni ottenute
                  for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
                    // recupero il tratto di curva corrente
                     PtrOwner<ICurve> pCrv( pLineLinkProjected->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
                     if ( IsNull( pCrv)  ||  ! pCrv->IsValid()) // troppo piccolo...
                        continue ; // passo al tratto di classificazione successivo
                    // se la curva non è esterna alla regione, allora la conservo (non rivina le Stm)
                     if ( ccClass[i].nClass != CRVC_OUT) {
                        if ( ! pCompoLink->AddCurve( Release( pCrv), true, 25 * EPS_SMALL))
                           return false ;
                     }
                    // se la curva è esterna, allora devo seguire il bordo della regione di classificazione
                     else {
                       // recupero gli estremi del segmento di classificazione esterno alla pSfrClass
                        Point3d ptS_sfr ; pLineLinkProjected->GetPointD1D2( ccClass[i].dParS, ICurve::FROM_MINUS, ptS_sfr) ;
                        Point3d ptE_sfr ; pLineLinkProjected->GetPointD1D2( ccClass[i].dParE, ICurve::FROM_MINUS, ptE_sfr) ;
                       // scorro tutti i loop della regione di classificazione
                        for ( int j = 0 ; j < int( vCrvSfrLoops.size()) ; ++ j) {
                          // se i punti trovati sono sul loop corrente
                           if ( vCrvSfrLoops[j]->IsPointOn( ptS_sfr, 25 * EPS_SMALL)  &&
                                vCrvSfrLoops[j]->IsPointOn( ptE_sfr, 25 * EPS_SMALL)) {
                             // devo capire quale delle due curve (pCrvA, pCrvB) devo seguire sul bordo
                              double dUS ; vCrvSfrLoops[j]->GetParamAtPoint( ptS_sfr, dUS, 25 * EPS_SMALL) ;
                              double dUE ; vCrvSfrLoops[j]->GetParamAtPoint( ptE_sfr, dUE, 25 * EPS_SMALL) ;
                              PtrOwner<ICurveComposite> pCrvA( ConvertCurveToComposite( vCrvSfrLoops[j]->CopyParamRange( dUS, dUE))) ;
                              PtrOwner<ICurveComposite> pCrvB( ConvertCurveToComposite( vCrvSfrLoops[j]->CopyParamRange( dUE, dUS))) ;
                             // tra le due curve (pCrvA, pCrvB) scelgo quella con lunghezza minore
                              double dLenA = INFINITO ; double dLenB = INFINITO ;
                              if ( ! IsNull( pCrvA)  &&  pCrvA->IsValid())
                                 pCrvA->GetLength( dLenA) ;
                              if ( ! IsNull( pCrvB)  &&  pCrvB->IsValid()) {
                                // la pCrvB è sempre percorsa in senso opposto
                                 pCrvB->Invert() ;
                                 pCrvB->GetLength( dLenB) ;
                              }
                             // aggiungo la curva
                              if ( ! pCompoLink->AddCurve( dLenA < dLenB ? Release( pCrvA) : Release( pCrvB), true, 25 * EPS_SMALL))
                                 return false ;
                           }
                        }
                     }
                  }
                 // se il link trovato non è valido, errore
                  if ( ! pCompoLink->IsValid())
                     return false ;

                 // porto il link sulla curva attuale di silhouette e lo proietto sulla pStm (sono in locale)
                  double dSfrDistNext = vCrvCompo[nNextRow][nNextCol_path]->GetTempParam( 0) ;
                  pCompoLink->Translate( Z_AX * min( dSfrDistCurr, dSfrDistNext)) ;

                  #if ENABLE_ZCONST_DEBUG
                     int _d = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoLink->Clone()) ;
                     m_pGeomDB->SetMaterial( _d, LIME) ;
                  #endif

                  if ( ! CalcZConstProjectedLink( pCAvTlStm, frXY, frSurf, vtTool, dDepth, ptStartLink, ptEndLink, pCompoLink))
                     return false ;

                  #if ENABLE_ZCONST_DEBUG
                     int _e = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoLink->Clone()) ;
                     m_pGeomDB->SetMaterial( _e, RED) ;
                  #endif

                 // aggiungo le curve ritrovate al percorso attuale
                  if ( ! vCrvPath.back()->AddCurve( Release( pCompoLink), true, 1500 * EPS_SMALL)  ||
                       ! vCrvPath.back()->AddCurve( Release( vCrvCompo[nNextRow][nNextCol_path]), true, 1500 * EPS_SMALL))
                     return false ;
               }
               vCrvPath.back()->GetEndPoint( ptCurrEnd) ; // aggiorno il punto finale del percorso
               vCrvPath.back()->SetTempProp( nNextRow + 1, 1) ; // salvo come seconda temp prop il piano a cui sono
            }
         }
      }
   }
  // se non ho percorsi, non faccio nulla
   if ( vCrvPath.empty())
      return true ;
  // se ho percorsi non validi, errore
   for ( int i = 0 ; i < int( vCrvPath.size()) ; ++ i) {
      if ( vCrvPath[i] == nullptr  ||  ! vCrvPath[i]->IsValid())
         return false ;
   }

  // preso come riferimento il primo percorso, ordino i successivi in base alla vicinanza
   Point3d ptRef ; vCrvPath.front()->GetEndPoint( ptRef) ;
   double dSqMaxDist = INFINITO ;
   for ( int i = 1 ; i < int( vCrvPath.size()) ; ++ i) {
      int nNextInd = i + 1 ;
      for ( int j = nNextInd ; j < int( vCrvPath.size()) ; ++ j) {
         Point3d ptS ; vCrvPath[j]->GetStartPoint( ptS) ;
         double dCurrSqDist = SqDist( ptS, ptRef) ;
         if ( dCurrSqDist < dSqMaxDist) {
            dSqMaxDist = dCurrSqDist ;
            nNextInd = j ;
         }
      }
      if ( nNextInd != i + 1)
         swap( vCrvPath[i], vCrvPath[nNextInd]) ;
      dSqMaxDist = INFINITO ;
   }

  // riporto i percorsi nel frame originale
   for ( int i = 0 ; i < int( vCrvPath.size()) ; ++ i)
      vCrvPath[i]->ToGlob( frXY) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CalcZConstProjectedLink( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frPocket,
                                        const Frame3d& frSurf, const Vector3d& vtTool, double dDepth,
                                        const Point3d ptStart_forced, const Point3d ptEnd_forced,
                                        ICurveComposite* pCrv)
{
  // funzione per proiettare una curva su una supericie trimesh passando per la silhouette
  // controllo dei parametri
   if ( pCAvTlStm == nullptr  ||  pCrv == nullptr  ||  ! pCrv->IsValid())
      return false ;
  // approssimo la curva con una polilinea
   PolyLine PL ;
   if ( ! pCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
     return false ;
  // eventuale aggiunta di punti per garantire max distanza
   const double MIN_DIST = 1. ;
   const double MAX_DIST = 50. ;
   double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
   if ( ! PL.AdjustForMaxSegmentLen( dDist))
      return false ;
  // porto nel riferimento delle superfici
   PL.ToGlob( frPocket) ;
  // porto i dati geometrici in locale alle superfici
   Vector3d vtAxL = GetToLoc( vtTool, frSurf) ;
   Vector3d vtMoveL = vtAxL ;
  // traslo della lunghezza utensile diminuita dell'affondamento
   PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
  // eseguo il test del percorso
   if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox))
      return false ;
  // contro-traslo della lunghezza utensile
   PL.Translate( - vtAxL * m_TParams.m_dLen) ;
  // riporto la polilinea nel riferimento della curva
   PL.ToLoc( frPocket) ;
  // elimino i punti allineati
   PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
  // sostituisco primo ed ultimo punto con quelli forzati
   PL.EraseFirstUPoint() ;
   PL.EraseLastUPoint() ;
   PL.AddUPoint( 0, ptStart_forced, false) ;
   PL.AddUPoint( PL.GetPointNbr(), ptEnd_forced, true) ;
  // controllo di non essere sceso oltre la depth (il link non per forza è vicino ad una curva di livello)
   PNTULIST& myPtUList = PL.GetUPointList() ;
   for ( POINTU& myPtU : myPtUList) {
      #if ENABLE_ZCONST_DEBUG
         PtrOwner<IGeoPoint3d> myPt( CreateGeoPoint3d()) ;
         myPt->Set( myPtU.first) ;
         int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPt->Clone()) ;
         m_pGeomDB->SetMaterial( a, WHITE) ;
      #endif // ENABLE_OPTIMAL_DEBUG

      if ( myPtU.first.z < - dDepth)
         myPtU.first.z = - dDepth ;
   }
  // creo una curva composita a partire dalla polilinea
   PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
   if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
      return false ;
  // sostituisco la vecchia curva con la nuova
   pCrv->CopyFrom( pCompo) ;
   return true ;

}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{

  // controllo che la regione sia definita correttamente
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;

  // aggiorno la ProgressBar del 5% per simulare l'inizio della funzione
   ExeProcessEvents( 5, 0) ;

  // aggiusto la regione a seconda dei parametri e la porto nel frame locale delle superfici
   PtrOwner<ISurfFlatRegion> pSfrClass( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + m_Params.m_dOverlap, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrClass)  ||  ! pSfrClass->IsValid()  ||  ! pSfrClass->ToLoc( frSurf))
      return false ;

  // inizializzo la classe di calcolo delle silhouette
   CISURFTMPVECTOR vpStm ; vpStm.reserve( vSrfLoc.size()) ;
  // scorro le superfici
   for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
     // recupero la superficie TriMesh e se valida, la memorizzo
      const ISurfTriMesh* pStm = GetSurfTriMesh( vSrfLoc[i].Get()) ;
      if ( pStm != nullptr  &&  pStm->IsValid()  &&  pStm->GetTriangleCount() > 0)
         vpStm.emplace_back( pStm) ;
   }
   PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
   if ( IsNull( pCavParSilh)  ||
        ! pCavParSilh->SetDataForRegion( vpStm, pSfrClass, m_TParams.m_dSideAng, m_TParams.m_dDiam,
                                         m_TParams.m_dCornRad, m_TParams.m_dMaxMat, GetOffsR(), SILH_SAMPLING, ANG_TOL_STD_DEG))
      return false ;

  // aggiorno la ProgressBar al 30%
   ExeProcessEvents( 30, 0) ;

  // recupero le curve singole definite dal bordo della Silhouette
   vector<ICRVCOMPOPOVECTOR> vCrvCompo ;
   if ( ! CalcZConstSilCrv( pCavParSilh, vSrfLoc, frSurf, pSfrClass, vtTool, dDepth, vCrvCompo)) {
      m_pMchMgr->SetLastError( 3126, "Error in SurfFinishing : Computing ZConst Curves failed") ;
      return false ;
   }
  // se non ho curve, esco
   bool bNoCrv = true ;
   for ( int i = 0 ; i < int( vCrvCompo.size())  &&  bNoCrv ; ++ i)
      bNoCrv = ( vCrvCompo[i].empty()) ;
   if ( bNoCrv)
      return true ;

  // collego tra loro le curve trovate
   ICRVCOMPOPOVECTOR vCrvPath ;
   if ( ! CreateZConstPaths( pCAvTlStm, frSurf, vCrvCompo, vtTool, pSfrClass, dDepth, vCrvPath)) {
      m_pMchMgr->SetLastError( 3127, "Error in SurfFinishing : Computing ZConst Paths failed") ;
      return false ;
   }
  // se non ho percorsi, errore
   if ( vCrvPath.empty())
      return false ;
   ExeProcessEvents( 90, 0) ;

  // porto tutti i percorsi in Globale
   for ( int i = 0 ; i < int( vCrvPath.size()) ; ++ i)
      vCrvPath[i]->ToGlob( frSurf) ;

  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // ciclo sulle curve risultanti
   bool bStart = true ;
   for ( int k = 0 ; k < int( vCrvPath.size()) ; ++ k) {
     // determino in che piano di partenza e il piano di arrivo
      int nStartPlane = vCrvPath[k]->GetTempProp( 0) ;
      int nEndPlane = vCrvPath[k]->GetTempProp( 1) ;
     // ciclo sulle curve elementari
      int nMaxInd = vCrvPath[k]->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = vCrvPath[k]->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
        // se prima entità
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // controllo che tale punto sia al di fuori della regione piana
            bool bIsInside = false ;
            if ( IsPointInsideSurfFr( ptP1 + vtTool * ( m_Params.m_dSideStep * nStartPlane), pSfrClass, EPS_SMALL, bIsInside))
               ptP1 = ptStart ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
          if ( pCurve->GetType() == CRV_LINE) {
             ICurveLine* pLine = GetCurveLine( pCurve) ;
             Point3d ptP3 = pLine->GetEnd() ;
             Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
             SetFeed( GetRightFeed( vtMove, vtTool)) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
          else if ( pCurve->GetType() == CRV_ARC) {
             ICurveArc* pArc = GetCurveArc( pCurve) ;
             Point3d ptCen = pArc->GetCenter() ;
             double dAngCen = pArc->GetAngCenter() ;
             Vector3d vtN = pArc->GetNormVersor() ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
             SetFeed( GetFeed()) ;
             if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // controllo che tale punto sia al di fuori della regione piana
            bool bIsInside = false ;
            if ( IsPointInsideSurfFr( ptP1 + vtTool * ( m_Params.m_dSideStep * nStartPlane), pSfrClass, EPS_SMALL, bIsInside))
               ptP1 = ptEnd ;
           // se ultima uscita globale del percorso
            if ( k == int( vCrvPath.size()) - 1) {
              // aggiungo LeadOut
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
                  return false ;
               }
              // aggiungo retroazione finale
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, nEndPlane * m_Params.m_dSideStep, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
           // altrimenti
            else {
              // determino elevazione su fine uscita
               double dEndElev ;
               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
               dEndElev -= ( ptP1 - ptEnd) * vtTool ;
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }

   ExeProcessEvents( 100, 0) ;
   return true ;

}

//----------------------------------------------------------------------------
bool
SurfFinishing::ApproxSilhouetteClosedPLForOptimal( PolyLine& PL, double dSampleTol, double dMaxLinTol, double dAngTol, double dLinFeaTol,
                                                   ICurveComposite* pCompoPL)
{
  // approssimazione di una polyline di Silhouette per rimuovere Spikes di proiezione
  // controllo dei parametri
   if ( pCompoPL == nullptr)
      return false ;
   pCompoPL->Clear() ;
  // se aperta errore
   Plane3d plPL ;
   double dArea ;
   if ( ! PL.IsClosedAndFlat( plPL, dArea))
      return false ;
  // semplifico rimuovendo i punti allineati
   PL.RemoveAlignedPoints( dSampleTol + 10 * EPS_SMALL) ;
  // essendo chiusa, se presenti meno di 4 punti, non faccio nulla
   int nPts = PL.GetPointNbr() ;
   if ( nPts < 4)
      return true ;
  // porto la PolyLine nel frame LocaleXY
   Frame3d frLoc ;
   if ( ! frLoc.Set( plPL.GetPoint(), plPL.GetVersN()))
      return false ;
   PL.ToLoc( frLoc) ;

  // --------------------------- scelta del punto iniziale ------------------------------

  // creo un vettore contenente tutti i punti ( cerco nel mentre il segmento più lungo)
   PNTVECTOR vPt ; vPt.reserve( nPts) ;
   int nLongEdge = -1 ;
   double dMaxSqLen = 0. ;
   Point3d myPt ;
   if ( ! PL.GetFirstPoint( myPt))
      return false ;
   vPt.emplace_back( myPt) ;
   while ( PL.GetNextPoint( myPt)) {
      double dCurrSqDist = SqDist( vPt.back(), myPt) ;
      if ( dCurrSqDist > dMaxSqLen) {
         dMaxSqLen = dCurrSqDist ;
         nLongEdge = int( vPt.size()) - 1 ;
      }
      vPt.emplace_back( myPt) ;
   }
   if ( nLongEdge < 0  ||  nLongEdge > nPts - 2)
      return false ;
  // calcolo il punto iniziale come punto medio del segmento più lungo
   Point3d ptStart = Media( vPt[nLongEdge], vPt[nLongEdge + 1]) ;
   ChangePolyLineStart( PL, ptStart, 10 * EPS_SMALL) ;
   nPts = PL.GetPointNbr() ;

  // ---------------------- modifica dei punti Spike ---------------------------------

  // creo un vettore di punti a partire dai punti della PolyLine
   PNTVECTOR vPts ; vPts.reserve( nPts) ;
   PL.GetFirstPoint( myPt) ;
   vPts.emplace_back( myPt) ;
   while ( PL.GetNextPoint( myPt))
      vPts.emplace_back( myPt) ;

  // dichiaro i versori tangenti consecutivi per il percorso della PolyLinea
   Vector3d vtTanPrev, vtTan, vtTanAfter ;
  // recupero il cosendo della tolleranza angolare
   double dCosAngTol = abs( cos( dAngTol * DEGTORAD)) ;
  // calcolo il quadrato della tolleranza lineare
   double dSqMaxLinTol = dMaxLinTol * dMaxLinTol ;
  // ciclo tutti i punti della PolyLine
   for ( int i = 2 ; i < int( vPts.size()) - 1 ; ++ i) {
     // se distanza tra punto attuale e precedente sopra al tolleranza, passo ai successivi
      if ( SqDist( vPts[i], vPts[i-1]) > dSqMaxLinTol)
         continue ;
     // calcolo il versore tangente del segmento pecedente
      vtTanPrev = vPts[i-1] - vPts[i-2] ;
      vtTanPrev.Normalize() ;
     // calcolo versore tangente attuale
      vtTan = vPts[i] - vPts[i-1] ;
      vtTan.Normalize() ;
     // recupero la direzione successia
      vtTanAfter = vPts[i+1] - vPts[i] ;
      vtTanAfter.Normalize() ;
     // controllo se l'angolo tra la direzione attuale e precedente supera la tolleranza
      if ( abs( vtTanPrev * vtTan) > dCosAngTol  &&  abs( vtTan * vtTanAfter) > dCosAngTol)
         continue ; // se uno dei due sotto la tolleranza, analizzo segmento successivo
     // se Spike individuato, modifico il punto corrente con il punto medio del segmento attuale
      vPts[i] = Media( vPts[i], vPts[i-1]) ;
     // il punto precedente diventa uguale all' i-2-esimo
      vPts[i-1] = vPts[i-2] ;
   }

  // a partire da questi punti, creo la PolyLine
   double dPar = -1 ;
   PolyLine myPL ;
   myPL.AddUPoint( ++ dPar, vPts[0]) ; // il primo punto è automaticamente inserito
   Point3d myLastPtInPL = vPts[0] ;
   for ( int i = 1 ; i < int( vPts.size()) ; ++ i) {
     // se il punto corrente è già inserito nella PolyLine, passo al successivo
      if ( AreSamePointApprox( vPts[i], myLastPtInPL))
         continue ;
     // altrimenti inserisco il punto nella Polyline e aggiorno il punto finale
      myPL.AddUPoint( ++ dPar, vPts[i]) ;
      myLastPtInPL = vPts[i] ;
   }
  // chiudo la PolyLine per sicurezza
   myPL.Close() ;

  // swap
   swap( PL, myPL) ;

  // recupero la curva composita dalla polyLine
   if ( ! pCompoPL->FromPolyLine( PL)  ||  ! pCompoPL->IsValid())
      return false ;

  // approssimo con archi
   PolyArc PA ;
   double dMyLinFea = dLinFeaTol ;
   double dMyAngTol = dAngTol ;
   if ( dMaxLinTol > LIN_TOL_STD) {
      double dCoeff = ( dMaxLinTol - LIN_TOL_STD) / LIN_TOL_STD ;
      dMyLinFea = min( LIN_FEA_STD + 1.0 * dCoeff * LIN_FEA_STD, 400.) ;
      dMyAngTol = min( ANG_TOL_STD_DEG + 0.2 * dCoeff * ANG_TOL_STD_DEG, 60.) ;
   }
   if ( pCompoPL->ApproxWithArcsEx( dMaxLinTol, dMyAngTol, dMyLinFea, PA)) {
      PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
      if ( ! IsNull( pTempCrv)  &&
           pTempCrv->FromPolyArc( PA)  &&
           pTempCrv->RemoveSmallDefects( dMaxLinTol, ANG_TOL_STD_DEG)  &&
           pTempCrv->MergeCurves( dMaxLinTol, ANG_TOL_STD_DEG))  {
         pCompoPL->CopyFrom( pTempCrv) ;
      }
   }
  // riporto la curva nel frame di partenza
   pCompoPL->ToGlob( frLoc) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetSfrBySilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double dDepth,
                                   double dSilTolSamp, double dSilTolLin,
                                   double dSilTolAng, ISurfFlatRegion* pSfrSil)
{
  // funzione per resitutire una regione piana data la classe di calcolo per silhouette
  // controllo dei parametri
   if ( pSfrSil == nullptr)
      return false ;
   pSfrSil->Clear() ;
  // recupero il vettore di PolyLine della silhouette
   POLYLINEVECTOR vPL ;
   if ( ! pCavParSilh->GetSilhouette( - dDepth, vPL))
      return false ;
  // creo la regione piana dalle PolyLine ricavate dalla Silhouette
   SurfFlatRegionByContours SfrMaker ;
   for ( auto& PL : vPL) {
     // recupero la curva in base alla polyLine
      PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
      if ( IsNull( pSilCrv))
         return false ;
      if ( ! ApproxSilhouetteClosedPLForOptimal( PL, dSilTolSamp, dSilTolLin, ANG_TOL_STD_DEG, LIN_FEA_STD, pSilCrv))
         return false ;
     // aggiungo per regione
      if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
         return false ;
   }
  // definisco la regione piana
   PtrOwner<ISurfFlatRegion> pSfrTmp( SfrMaker.GetSurf()) ;
   if ( ! IsNull( pSfrTmp)  &&  pSfrTmp->IsValid())
      pSfrSil->CopyFrom( pSfrTmp) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::SplitStmTrianglesByClippingAngle( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
                                                 const Vector3d& vtTool, double dDepth, double dClippingAngle, double dTolerAngle,
                                                 ISURFTMPOVECTOR& vpStm1, ISURFTMPOVECTOR& vpStm2, double& dMaxFrontTriaRad) const
{
  // Funzione per ciclare i triangoli di una TriMesh (*pStm)
  // I triangoli che formano un angolo, in valore assoluto con vtTool, maggiore di dClippingAngle
  // vengono inseriti nella zuppa TriaSoupZConst, gli altri in TriaSoupSpiral
  // dMaxFrontTriaRad è il raggio massimo dei triangoli con normale che si discosta da vtTool per
  // meno di dTolerAngle (triangoli frontalieri)

  // definisco il piano di taglio alla profondità massima
   Point3d ptCenter ; pSfrCnt->GetCentroid( ptCenter) ;
   Plane3d plClipping ;
   Point3d ptPlCl = GetToLoc( ptCenter, frSurf) ;
   Vector3d vtNCl = GetToLoc( vtTool, frSurf) ;
   if ( ! plClipping.Set( ptPlCl - vtNCl * ( dDepth + 25 * EPS_SMALL), - vtNCl))
      return false ;

  // porto il versore utensile nel riferimento locale
   Vector3d vtToolLoc = vtTool ; vtToolLoc.ToLoc( frSurf) ;
  // aggiusto i parametri
   dClippingAngle = Clamp( dClippingAngle, 30., 60.) ;   // [30°,60°]
   dTolerAngle = Clamp( dTolerAngle, 1., 5.) ;           // [1°,5°]

  // definizione delle costanti
   double dCosLimit = cos( dClippingAngle * DEGTORAD) ;
   double dCosLimSup = cos( ( dClippingAngle - dTolerAngle) * DEGTORAD) ;
   double dCosLimInf = cos( max( 0., ( dClippingAngle + dTolerAngle)) * DEGTORAD) ;

  // scorro le superfici locali
   for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
     // recupero la regione come superficie trimesh (controllo la sua validità)
      PtrOwner<ISurfTriMesh> pStm( CloneSurfTriMesh( GetSurfTriMesh( vSrfLoc[i].Get()))) ;
      if ( IsNull( pStm)  ||  ! pStm->IsValid())
         continue ;
     // NB. devo tagliare la supericie con un piano diretto come vtTool a profondità dDepth
     // ( altrimenti rischio di calcolare regioni piane inutili)
      if ( ! pStm->Cut( plClipping, false))
         return false ;
     // se non rimane nulla, passo alla successiva
      if ( IsNull( pStm)  ||  ! pStm->IsValid()  ||  pStm->GetTriangleCount() == 0)
         continue ;
     // definizione delle sue zuppe di triangoli
      StmFromTriangleSoup StmSoup1, StmSoup2 ;
      StmSoup1.Start() ; StmSoup2.Start() ;
     // scorro i triangoli della superficie
      for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
        // recupero il triangolo corrente (controllo la sua validità)
         Triangle3d Tria ; pStm->GetTriangle( nT, Tria) ;
         if ( ! Tria.IsValid())
            continue ;
        // recupero la normale del triangolo
         Vector3d vtN_tria = Tria.GetN() ;
        // recupero il valore coseno dell'angolo
         double dCos = vtN_tria * vtToolLoc ;
        // se coseno negativo scarto il triangolo, non si lavorano i sottosquadra
         if ( dCos < - EPS_SMALL)
            continue ;
        // se triangolo è forntaliero, lo inserisco nel vettore
         if ( dCos < dCosLimSup  &&  dCos > dCosLimInf) {
           // recupero il raggio della sfera che contine il triangolo
            BBox3d BBoxTria ;
            double dRad ;
            if ( ! Tria.GetLocalBBox( BBoxTria)  ||  ! BBoxTria.GetRadius( dRad))
               return false ;
           // se raggio più grande del limite superiore, aggiorno
            if ( dRad > dMaxFrontTriaRad)
               dMaxFrontTriaRad = dRad ;
         }
        // se la normale del triangolo è sotto la tolleranza, lo inserisco nella zuppa ZConst
        // più il prodottoscalare tende a 0, più i versori sono distanti
         if ( ( abs( dCos) < dCosLimit + EPS_ANG_ZERO))
            StmSoup1.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
         else
            StmSoup2.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
      }
     // fine scorrimento dei triangoli
      StmSoup1.End() ; StmSoup2.End() ;
     // recupero le superfici trimesh per ZCosnt (stmSoup1)
      PtrOwner<ISurfTriMesh> pStmCurr( StmSoup1.GetSurf()) ;
      while ( ! IsNull( pStmCurr)  &&  pStmCurr->IsValid()  &&  ( pStmCurr->GetTriangleCount() > 0)) {
        // rimuovo le parti di superficie troppo piccole
         for ( int nP = 0 ; nP < pStmCurr->GetPartCount() ; ++ nP) {
            double dArea ;
            if ( pStmCurr->GetPartArea( nP, dArea)  &&  dArea < EPS_SMALL) {
               pStmCurr->RemovePart( nP) ;
               -- nP ;
            }
         }
        // se rimane una superficie valida, allora la memorizzo
         if ( pStmCurr->IsValid()  &&  ( pStmCurr->GetTriangleCount() > 0))
            vpStm1.emplace_back( Release( pStmCurr)) ;
        // recupero eventuale altra superficie TriMesh
         pStmCurr.Set( StmSoup1.GetSurf()) ;
      } ;

     // recupero le superfici trimesh per Spiral (stmSoup2)
      pStmCurr.Set( StmSoup2.GetSurf()) ;
      while ( ! IsNull( pStmCurr)  &&  pStmCurr->IsValid()  &&  ( pStmCurr->GetTriangleCount() > 0)) {
        // rimuovo le parti di superficie troppo piccole
         for ( int nP = 0 ; nP < pStmCurr->GetPartCount() ; ++ nP) {
            double dArea ;
            if ( pStmCurr->GetPartArea( nP, dArea)  &&  dArea < EPS_SMALL) {
               pStmCurr->RemovePart( nP) ;
               -- nP ;
            }
         }
        // se rimane una superficie valida, allora la memorizzo
         if ( pStmCurr->IsValid()  &&  ( pStmCurr->GetTriangleCount() > 0))
            vpStm2.emplace_back( Release( pStmCurr)) ;
        // recupero eventuale altra superficie TriMesh
         pStmCurr.Set( StmSoup2.GetSurf()) ;
      } ;
   }

   #if ENABLE_OPTIMAL_DEBUG
      for ( int i = 0 ; i < int( vpStm1.size()) ; ++ i) { // ZConst -> Viola
         PtrOwner<ISurfTriMesh> pStmToDraw( CloneSurfTriMesh( vpStm1[i])) ;
         pStmToDraw->ToGlob( frSurf) ;
         int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmToDraw->Clone()) ;
         m_pGeomDB->SetMaterial( _o, PURPLE) ;
      }
      for ( int i = 0 ; i < int( vpStm2.size()) ; ++ i) { // Spiral -> Verde
         PtrOwner<ISurfTriMesh> pStmToDraw( CloneSurfTriMesh( vpStm2[i])) ;
         pStmToDraw->ToGlob( frSurf) ;
         int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmToDraw->Clone()) ;
         m_pGeomDB->SetMaterial( _o, GREEN) ;
      }
   #endif

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::OrderOptimalPathsByZLoc( const ISurfFlatRegion* pSfr, VECTORPATHS& vCrvPaths)
{
  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
  // se ho un solo percorso, non faccio nulla
   if ( int( vCrvPaths.size()) == 1)
      return true ;
  // creo un frame sulla superficie
   Frame3d frOrder ;
   Point3d ptOrder ; pSfr->GetCentroid( ptOrder) ;
   Vector3d vtOrder = pSfr->GetNormVersor() ;
   if ( ! frOrder.Set( ptOrder, vtOrder))
      return false ;
   DBLVECTOR vZorder( vCrvPaths.size()) ;
   for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i) {
      Point3d ptStart ; vCrvPaths[i].pCrvPath->GetStartPoint( ptStart) ;
      ptStart.ToLoc( frOrder) ;
      vZorder[i] = ptStart.z ;
   }
  // swap degli indici per ordine delle Z locali
   for ( int i = 0 ; i < int( vZorder.size()) - 1 ; ++ i) {
      for ( int j = i + 1 ; j < int( vZorder.size()) ; ++ j) {
         if ( vZorder[j] > vZorder[i]) {
            swap( vZorder[j], vZorder[i]) ;
            swap( vCrvPaths[j], vCrvPaths[i]) ;
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::ChooseFinishingForOptimal( const ISurfFlatRegion* pSfr, int nChunk, bool& bSpiral,
                                          double& dSideAng)
{
  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
  // controllo valore di nChunk
   if ( nChunk < 0  ||  nChunk >= pSfr->GetChunkCount())
      return false ;
  // informazioni sul Chunk
   int nLines = 0 ; double dMaxLineLen = 0. ; Vector3d vtTanMaxLine ;
   int nArcs = 0 ; double dMaxArcLen = 0. ;
   BBox3d BBox ; Vector3d vtX ;
   for ( int nL = 0 ; nL < pSfr->GetLoopCount( nChunk) ; ++ nL) {
     // recupero il loop come curva composita
      PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nChunk, nL))) ;
      if ( IsNull( pCompoLoop)  ||  ! pCompoLoop->IsValid())
         return false ;
     // se loop esterno calcolo il Box
      if ( nL == 0) {
         PolyLine PL ;
         if ( ! pCompoLoop->ApproxWithLines( 100 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
            return false ;
         Point3d ptCenter ;
         double dLen ; double dHeight ;
         if ( ! PL.GetMinAreaRectangleXY( ptCenter, vtX, dLen, dHeight))
            return false ;
      }
     // scorro le curve del Loop
      for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
         const ICurve* pCurve = pCompoLoop->GetCurve( nU) ;
         if ( pCurve == nullptr  ||  ! pCurve->IsValid())
            return false ;
        // se arco
         if ( pCurve->GetType() == CRV_ARC) {
            ++ nArcs ;
            double dLen ; pCurve->GetLength( dLen) ;
            if ( dLen > dMaxArcLen)
               dMaxArcLen = dLen ;
         }
        // se linea
         else if ( pCurve->GetType() == CRV_LINE) {
            ++ nLines ;
            double dLen ; pCurve->GetLength( dLen) ;
            if ( dLen > dMaxLineLen) {
               dMaxLineLen = dLen ;
               pCurve->GetStartDir( vtTanMaxLine) ;
            }
         }
      }
   }
  // di base lavorazione Spiral
   bSpiral = true ;
  // se l'entità più lunga è la linea
   if ( dMaxLineLen > dMaxArcLen) {
     // se ci sono in genere più linee che archi (60% linee)
      if ( nLines / ( nLines + nArcs + 1) > .6) {
        // se la direzione principale della linea concide con la direzione massima del box minimo
         if ( AreSameOrOppositeVectorApprox( vtTanMaxLine, vtX)) {
            bSpiral = false ; // ZigZag
            X_AX.GetAngle( vtX, dSideAng) ;
            dSideAng = abs( dSideAng) ;
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
ISurfTriMesh*
SurfFinishing::SplitStmTriaUnderClippingAngle( const SurfLocal SrfLoc, const Vector3d& vtTest, double dClippingAngle,
                                               double dFrontTriaTolerAng,  double& dMaxFrontTriaRad) const
{
  // definisco le tolleranze
   double dCosLimit = cos( dClippingAngle * DEGTORAD) ;
   double dCosLimSup = cos( ( dClippingAngle - dFrontTriaTolerAng) * DEGTORAD) ;
   double dCosLimInf = cos( max( 0., ( dClippingAngle + dFrontTriaTolerAng)) * DEGTORAD) ;

  // recupero una superficie formata solo dai triangoli la cui normale ha un angolo minore di CLIPPING_EDGE
  // rispetto al versore utensile
  // scorro le superfici
   StmFromTriangleSoup SpiralSoup ; SpiralSoup.Start() ;
  // recupero la TriMesh ( solo la parte sopra alla dDepth)
   const ISurfTriMesh* pStm = GetSurfTriMesh( SrfLoc.Get()) ;
   if ( pStm == nullptr  ||  ! pStm->IsValid())
      return nullptr ;
  // scorro i triangoli
   for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
     // recupero il triangolo corrente (controllo la sua validità)
      Triangle3d Tria ; pStm->GetTriangle( nT, Tria) ;
      if ( ! Tria.IsValid())
         continue ;
     // recupero la normale del triangolo
      Vector3d vtN_tria = Tria.GetN() ;
     // recupero il valore coseno dell'angolo
      double dCos = vtN_tria * vtTest ;
     // se coseno negativo scarto il triangolo, non si lavorano i sottosquadra
      if ( dCos < - EPS_SMALL)
         continue ;
     // se triangolo è forntaliero, lo inserisco nel vettore
      if ( dCos < dCosLimSup  &&  dCos > dCosLimInf) {
         // recupero il raggio della sfera che contine il triangolo
         BBox3d BBoxTria ;
         double dRad ;
         if ( ! Tria.GetLocalBBox( BBoxTria)  ||  ! BBoxTria.GetRadius( dRad))
            return nullptr ;
        // se raggio più grande del limite superiore, aggiorno
         if ( dRad > dMaxFrontTriaRad)
            dMaxFrontTriaRad = dRad ;
      }
     // se la normale del triangolo è sopra la tolleranza, lo inserisco nella zuppa Spiral
     // più il prodottoscalare tende a 0, più i versori sono distanti
      if ( ( abs( dCos) > dCosLimit + EPS_ANG_ZERO))
         SpiralSoup.AddTriangle( Tria.GetP( 0), Tria.GetP( 1), Tria.GetP( 2)) ;
   }
   SpiralSoup.End() ;

  // recupero la superficie trimesh dalla zuppa
   PtrOwner<ISurfTriMesh> pStmLoc( SpiralSoup.GetSurf()) ;
   if ( ! IsNull( pStmLoc)  &&  pStmLoc->IsValid()  &&  pStmLoc->GetTriangleCount() > 0) {
      pStmLoc->Repair() ; // rimozione possibili T-Junctions
      #if ENABLE_OPTIMAL_DEBUG
         int _o = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmLoc->Clone()) ;
         m_pGeomDB->SetMaterial( _o, PURPLE) ;
      #endif
   }

   return Release( pStmLoc) ;
}

//----------------------------------------------------------------------------
ISurfFlatRegion*
SurfFinishing::GetSfrProjectedStmLoops( const ISURFTMPOVECTOR& vStm, const ISurfFlatRegion* pSfrContour,
                                        const DBLVECTOR& vdLinFeaTol, const DBLVECTOR& vdAngTol, const DBLVECTOR& vdMaxLinTol) const
{
  // controllo della regione di controllo
   if ( pSfrContour == nullptr)
      return nullptr ;
   PtrOwner<ISurfFlatRegion> pSfr( CreateSurfFlatRegion()) ;
   if ( IsNull( pSfr))
      return nullptr ;
   if ( ! pSfrContour->IsValid())
      return Release( pSfr) ;

  // definisco piano di proiezione dalla regione
   Plane3d plProj ;
   Point3d ptC ; pSfrContour->GetCentroid( ptC) ;
   if ( ! plProj.Set( ptC, pSfrContour->GetNormVersor()))
      return nullptr ;
  // frame per classificazione delle curve (planeXY)
   Frame3d frXY ;
   if ( ! frXY.Set( ptC, pSfrContour->GetNormVersor()))
      return nullptr ;

  // per ogni superficie trimesh ...
   for ( int nS = 0 ; nS < int( vStm.size()) ; ++ nS) {
     // se non è valida allora passo alla successiva (potrebbe essere tutta associata a ZConst)
      if ( vStm[nS] == nullptr  || ! vStm[nS]->IsValid())
         continue ;
     // recupero le parti che la compongono
      for ( int nP = 0 ; nP < vStm[nS]->GetPartCount() ; ++ nP) {
        // se la Part corrente è piccola, la salto
         double dArea = 0. ;
         if ( vStm[nS]->GetPartArea( nP, dArea)  &&  dArea < EPS_SMALL)
            continue ;
        // recupero i Loop della parte corrente
         POLYLINEVECTOR vPL ;
         if ( ! vStm[nS]->GetPartLoops( nP, vPL))
            return nullptr ;
        // recupero un vettore di curve composite (in 3d)
         ICRVCOMPOPOVECTOR vCompoLoops ; vCompoLoops.reserve( vPL.size()) ;
         for ( int nL = 0 ; nL < int( vPL.size()) ; ++ nL) {
            if ( vPL[nL].IsClosed()) {
               PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
               if ( IsNull( pCompoLoop)  ||  ! pCompoLoop->FromPolyLine( vPL[nL])  ||  ! pCompoLoop->IsValid())
                  return nullptr ;
              // memorizzo la curva
               vCompoLoops.emplace_back( Release( pCompoLoop)) ;
            }
         }
        // creo un vettore di curve proiettate approssimate per la creazione della regione
         SurfFlatRegionByContours SfrPart ;
         for ( int nL = 0 ; nL < int( vCompoLoops.size()) ; ++ nL) {
            #if ENABLE_OPTIMAL_DEBUG
               //int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCompoLoops[nL]->Clone()) ;
               //m_pGeomDB->SetMaterial( _a, WHITE) ;
            #endif
           // la proietto sul piano di proiezione
            PtrOwner<ICurve> pCompoProj( ProjectCurveOnPlane( *vCompoLoops[nL], plProj)) ;
            if ( IsNull( pCompoProj)  ||  ! pCompoProj->IsValid())
               continue ;
            pCompoProj->ToLoc( frXY) ;
            SelfIntersCurve SIC( *pCompoProj) ;
            if ( SIC.GetIntersCount() > 0)
               continue ;
            pCompoProj->ToGlob( frXY) ;
            #if ENABLE_OPTIMAL_DEBUG
               //int _b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoProj->Clone()) ;
               //m_pGeomDB->SetMaterial( _b, AQUA) ;
            #endif
            SfrPart.AddCurve( Release( pCompoProj)) ;
         }
         PtrOwner<ISurfFlatRegion> pSfrPart( SfrPart.GetSurf()) ;
         if ( ! IsNull( pSfrPart)  &&  pSfrPart->IsValid()) {
           // controllo che sia orientata corretamente
            if ( AreOppositeVectorApprox( pSfrContour->GetNormVersor(), pSfrPart->GetNormVersor()))
               pSfrPart->Invert() ;
           // aggiungo alla regione *pSfr
            if ( pSfr->IsValid()) {
               if ( ! pSfr->Add( *pSfrPart))
                  return nullptr ;
            }
            else
               pSfr.Set( pSfrPart) ;
         }
      }
   }

   #if ENABLE_OPTIMAL_DEBUG
      Color myColor = AQUA ; myColor.SetAlpha( .25) ;
      int _b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfr->Clone()) ;
      m_pGeomDB->SetMaterial( _b, myColor) ;
   #endif

   return Release( pSfr) ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CalcShapedPoint( const PNTUVVECT& myInfoStart, const PNTUVVECT& myInfoEnd, bool bSpiral, const Vector3d& vtAxL,
                                const Vector3d& vtMoveL, double dClippingAngle, ICAvToolSurfTm* pCAvTlStm, Point3d& ptShaped, int _debug_ind) const
{

  // se il parametro dU tra Start ed End è decrescente non faccio nulla
   /*if ( get<1>( myInfoStart) < get<1>( myInfoEnd) + EPS_SMALL) {
      ptShaped = get<0>( myInfoStart) ;
      return true ;
   }*/

  // cos di ripartizione
   double dCosClipping = cos( dClippingAngle * DEGTORAD) ;

  // altrimenti effettuo bisezione
   const int MAX_ITER = 10 ;
   int nCount = 0 ;
   PNTUVVECT ptU_vt1 = make_tuple( get<0>( myInfoStart), get<1>( myInfoStart), get<2>( myInfoStart)) ;
   PNTUVVECT ptU_vt2 = make_tuple( get<0>( myInfoEnd), get<1>( myInfoEnd), get<2>( myInfoEnd)) ;
   Point3d ptMid = Media( get<0>( ptU_vt1), get<0>( ptU_vt2)) ;
   while ( nCount < MAX_ITER) {
     // se estremi coincidenti, allora mi fermo
      if ( SqDist( get<0>( ptU_vt1), get<0>( ptU_vt2)) < EPS_SMALL * EPS_SMALL) {
         ptShaped = ptMid ;
         return true ;
      }
     // verifica del punto medio
      Point3d ptTest = ptMid ;
      double dMove = 0. ;
      VCT3DVECTOR vVtN ;
      if ( ! pCAvTlStm->TestPointAdv( ptTest, vtAxL, vtMoveL, dMove, vVtN))
         return false ;

      bool bMidColl = false ;
      for ( int nV = 0 ; nV < int( vVtN.size()) ; ++ nV) {
         double dAbsCos = abs( vVtN[nV] * vtAxL) ;
         if ( ! bMidColl)
            bMidColl = ( bSpiral ? dAbsCos > dCosClipping + EPS_ANG_ZERO : dAbsCos < dCosClipping + EPS_ANG_ZERO) ;
      }
      bool b1Coll = false ;
      for ( int nV = 0 ; nV < int( get<2>( ptU_vt1).size()) ; ++ nV) {
         double dAbsCos = abs( get<2>( ptU_vt1)[nV] * vtAxL) ;
         if ( ! b1Coll)
            b1Coll = ( bSpiral ? dAbsCos > dCosClipping + EPS_ANG_ZERO : dAbsCos < dCosClipping + EPS_ANG_ZERO) ;
      }

      #if ENABLE_OPTIMAL_DEBUG
         PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
         pt->Set( ptMid) ;
         int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, _debug_ind, pt->Clone()) ;
         m_pGeomDB->SetMaterial( _a, bMidColl ? AQUA : ORANGE) ;
      #endif

      if ( b1Coll != bMidColl)
         ptU_vt2 = make_tuple( ptMid, dMove, vVtN) ;
      else
         ptU_vt1 = make_tuple( ptMid, dMove, vVtN) ;
      ptMid = Media( get<0>( ptU_vt1), get<0>( ptU_vt2)) ;
      ++ nCount ;
   }

   ptShaped = ptMid ;
   return true ;
}

//----------------------------------------------------------------------------
int
AdvancedProcessSquare( int nFlag, const INTVECTOR& vInds, const DBLVECTOR& vdU, INTINTVECTOR& vIndBounds)
{
  // controllo dei parametri
   if ( nFlag < 0 ||  nFlag > 15  ||
        int( vInds.size()) != 4  ||  int( vdU.size()) != 4  ||  int( vIndBounds.size()) != 4)
      return -1 ;
  // assegno valori di default agli indici degli estremi
   for ( int i = 0 ; i < 4 ; ++ i)
      vIndBounds[i] = make_pair( -1, -1) ;

   //----------------------------------------------------------------------------
   // Quadrato (C=corner E=edge) :
   // 
   //      C3 - E2 - C2
   //      |  *   *  |
   //      E3   *    E1
   //      |  *   *  |
   //      C0 - E0 - C1
   // 
   //----------------------------------------------------------------------------

  // LineTable avanzata
   static int LineTable[16][7] = { {  0, -1, -1, -1, -1, -1, -1},     // ( 0)
                                   {  2,  0,  1,  0,  2,  0,  3},     // ( 1)
                                   {  2,  1,  2,  1,  3,  1,  0},     // ( 2)
                                   {  1,  1,  2,  0,  3, -1, -1},     // ( 3)
                                   {  2,  2,  3,  2,  0,  2,  1},     // ( 4)
                                   { -1, -1, -1, -1, -1, -1, -1},     // ( 5) -> ambiguo
                                   {  1,  2,  3,  1,  0, -1, -1},     // ( 6)
                                   {  2,  2,  3,  1,  3,  0,  3},     // ( 7)
                                   {  2,  3,  0,  3,  1,  3,  2},     // ( 8)
                                   {  1,  0,  1,  3,  2, -1, -1},     // ( 9)
                                   { -1, -1, -1, -1, -1, -1, -1},     // ( 10) -> ambiguo
                                   {  2,  1,  2,  0,  2,  3,  2},     // ( 11)
                                   {  1,  3,  0,  2,  1, -1, -1},     // ( 12)
                                   {  2,  0,  1,  3,  1,  2,  1},     // ( 13)
                                   {  2,  3,  0,  2,  0,  1,  0},     // ( 14)
                                   {  0, -1, -1, -1, -1, -1, -1} } ;  // ( 15)
   static int LineTabelAmbiguos[4][9] = { {  2,  2,  3,  2,  1,  0,  1,  0,  3},    // ( 5-split)
                                          {  2,  1,  0,  1,  2,  3,  2,  3,  0},    // ( 10-split)
                                          {  2,  2,  3,  0,  3,  0,  1,  2,  1},    // ( 5-stick)
                                          {  2,  1,  2,  3,  2,  3,  0,  1,  0} } ; // ( 10-stick)
   int nLines = LineTable[nFlag][0] ;
  // se almeno una linea
   if ( LineTable[nFlag][0] > 0) {
      vIndBounds[0] = make_pair( vInds[LineTable[nFlag][1]], vInds[LineTable[nFlag][2]]) ;
      vIndBounds[1] = make_pair( vInds[LineTable[nFlag][3]], vInds[LineTable[nFlag][4]]) ;
   }
  // se due linee
   if ( LineTable[nFlag][0] == 2) {
      vIndBounds[2] = make_pair( vInds[LineTable[nFlag][3]], vInds[LineTable[nFlag][4]]) ;
      vIndBounds[3] = make_pair( vInds[LineTable[nFlag][5]], vInds[LineTable[nFlag][6]]) ;
   }
  // se ambiguo
   if ( LineTable[nFlag][0] == -1) {
      int nShift = ( vdU[0] * vdU[2] < vdU[1] * vdU[3] ? 0 : 1) ;
      vIndBounds[0] = make_pair( vInds[LineTabelAmbiguos[nFlag % 5 + nShift][1]],
                                 vInds[LineTabelAmbiguos[nFlag % 5 + nShift][2]]) ;
      vIndBounds[1] = make_pair( vInds[LineTabelAmbiguos[nFlag % 5 + nShift][3]],
                                 vInds[LineTabelAmbiguos[nFlag % 5 + nShift][4]]) ;
      vIndBounds[2] = make_pair( vInds[LineTabelAmbiguos[nFlag % 5 + nShift][5]],
                                 vInds[LineTabelAmbiguos[nFlag % 5 + nShift][6]]) ;
      vIndBounds[3] = make_pair( vInds[LineTabelAmbiguos[nFlag % 5 + nShift][7]],
                                 vInds[LineTabelAmbiguos[nFlag % 5 + nShift][8]]) ;
      nLines = 2 ;
   }

   return nLines ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::MarchingSquares( const VECTORCOLLISIONSFR& vPntM, bool bSpiral, int nStepX, int nStepY, double dClippingAngle,
                                const Vector3d& vtAxL, const Vector3d& vtMoveL, ICAvToolSurfTm* pCAvTlStm,
                                ICRVCOMPOPOVECTOR& vCrvCompo) const
{
   pair<int, int> _debug_inds = make_pair( GDB_ID_NULL, GDB_ID_ROOT) ;
   #if ENABLE_OPTIMAL_DEBUG
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "_marchingsquare") ;
      m_pGeomDB->SetStatus( nGrp, GDB_ST_ON) ;
      int nLyS = GDB_ID_NULL ;
      int nLyZC = GDB_ID_NULL ;
      if ( bSpiral) {
         nLyS = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
         m_pGeomDB->SetName( nLyS, "_spiral") ;
         m_pGeomDB->SetStatus( nLyS, GDB_ST_OFF) ;
         _debug_inds.first = nLyS ;
      }
      else {
         nLyZC = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
         m_pGeomDB->SetName( nLyZC, "_zconst") ;
         m_pGeomDB->SetStatus( nLyZC, GDB_ST_OFF) ;
         _debug_inds.second = nLyZC ;
      }
   #endif

  // Predispongo il concatenamento
   BIPNTVECTOR vBiPnt ; vBiPnt.reserve( 2 * ( nStepX + nStepY)) ;
   ChainCurves chainC ; chainC.Init( false, EPS_SMALL, 2 * ( nStepX + nStepY)) ;
  // Ciclo sui quadrati da analizzare
   for ( int j = 0 ; j < nStepY ; ++ j) {
      for ( int i = 0 ; i < nStepX ; ++ i) {
        // vettore degli indici
         INTVECTOR vInd{ i + j * ( nStepX + 1), ( i + 1) + j * ( nStepX + 1),
                         ( i + 1) + ( j + 1) * ( nStepX + 1), i + ( j + 1) * ( nStepX + 1)} ;
        // flag del quadrato
         int nFlag = ( bSpiral ? ( ( vPntM[vInd[0]].bInSpiral ? 1 : 0) + ( vPntM[vInd[1]].bInSpiral ? 2 : 0) +
                                 ( vPntM[vInd[2]].bInSpiral ? 4 : 0) + ( vPntM[vInd[3]].bInSpiral ? 8 : 0)) :
                                 ( ( vPntM[vInd[0]].bInZConst ? 1 : 0) + ( vPntM[vInd[1]].bInZConst ? 2 : 0) +
                                 ( vPntM[vInd[2]].bInZConst ? 4 : 0) + ( vPntM[vInd[3]].bInZConst ? 8 : 0))) ;
        // vettore degli estremi dei segmenti
         INTINTVECTOR vIndBounds( 4, make_pair( -1, -1)) ;
        // vettore dei parametri dU
         DBLVECTOR vdU{ get<1>( vPntM[vInd[0]].CollisionInfo), get<1>( vPntM[vInd[1]].CollisionInfo),
                        get<1>( vPntM[vInd[2]].CollisionInfo), get<1>( vPntM[vInd[3]].CollisionInfo)} ;
        // analisi del quadrato
         int nLines = AdvancedProcessSquare( nFlag, vInd, vdU, vIndBounds) ;
         if ( nLines == -1)
            return false ;
        // se esiste una linea
         if ( nLines > 0) {
           // controllo interpolazine
            Point3d ptL1s ;
            if ( ! CalcShapedPoint( vPntM[vIndBounds[0].first].CollisionInfo, vPntM[vIndBounds[0].second].CollisionInfo,
                                    bSpiral, vtAxL, vtMoveL, dClippingAngle, pCAvTlStm, ptL1s, bSpiral ? _debug_inds.first : _debug_inds.second))
               ptL1s = get<0>( vPntM[vIndBounds[0].first].CollisionInfo) ;
            Point3d ptL1e ;
            if ( ! CalcShapedPoint( vPntM[vIndBounds[1].first].CollisionInfo, vPntM[vIndBounds[1].second].CollisionInfo,
                                    bSpiral, vtAxL, vtMoveL, dClippingAngle, pCAvTlStm, ptL1e, bSpiral ? _debug_inds.first : _debug_inds.second))
               ptL1e = get<0>( vPntM[vIndBounds[1].first].CollisionInfo) ;
            vBiPnt.emplace_back( ptL1s, ptL1e) ;
            Vector3d vtDir1 = ptL1e - ptL1s ; vtDir1.Normalize() ;
            chainC.AddCurve( int( vBiPnt.size()), ptL1s, vtDir1, ptL1e, vtDir1) ;
            #if ENABLE_OPTIMAL_DEBUG
                  PtrOwner<ICurveLine> myLine( CreateCurveLine()) ;
                  myLine->Set( ptL1s, ptL1e) ;
                  if ( ! IsNull( myLine)  &&  myLine->IsValid()) {
                     myLine->SetExtrusion( vtAxL) ;
                     int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, bSpiral ? nLyS : nLyZC, myLine->Clone()) ;
                     m_pGeomDB->SetMaterial( _a, GREEN) ;
                  }
            #endif
           // interpolazione seconda linea
            if ( nLines == 2) {
               Point3d ptL2s ;
               if ( ! CalcShapedPoint( vPntM[vIndBounds[2].first].CollisionInfo, vPntM[vIndBounds[2].second].CollisionInfo,
                                       bSpiral, vtAxL, vtMoveL, dClippingAngle, pCAvTlStm, ptL2s, bSpiral ? _debug_inds.first : _debug_inds.second))
                  ptL2s = get<0>( vPntM[vIndBounds[2].first].CollisionInfo) ;
               Point3d ptL2e ;
               if ( ! CalcShapedPoint( vPntM[vIndBounds[3].first].CollisionInfo, vPntM[vIndBounds[3].second].CollisionInfo,
                                       bSpiral, vtAxL, vtMoveL, dClippingAngle, pCAvTlStm, ptL2e, bSpiral ? _debug_inds.first : _debug_inds.second))
                  ptL2e = get<0>( vPntM[vIndBounds[3].first].CollisionInfo) ;
               vBiPnt.emplace_back( ptL2s, ptL2e) ;
               Vector3d vtDir2 = ptL2e - ptL2s ; vtDir2.Normalize() ;
               chainC.AddCurve( int( vBiPnt.size()), ptL2s, vtDir2, ptL2e, vtDir2) ;
               #if ENABLE_OPTIMAL_DEBUG
                  PtrOwner<ICurveLine> myLine( CreateCurveLine()) ;
                  myLine->Set( ptL2s, ptL2e) ;
                  if ( ! IsNull( myLine)  &&  myLine->IsValid()) {
                     myLine->SetExtrusion( vtAxL) ;
                     int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, bSpiral ? nLyS : nLyZC, myLine->Clone()) ;
                     m_pGeomDB->SetMaterial( _a, YELLOW) ;
                  }
               #endif
            }
         }
      }
   }

  // recupero i contorni
   INTVECTOR vnId ;
   while ( chainC.GetChainFromNear( ORIG, false, vnId)) {
     // creo la curva
      vCrvCompo.emplace_back( CreateCurveComposite()) ;
      vCrvCompo.back()->AddPoint( vBiPnt[vnId[0]-1].first) ;
      for ( int i = 0 ; i < int( vnId.size()) ; ++ i)
         vCrvCompo.back()->AddLine( vBiPnt[vnId[i]-1].second) ;
      if ( ! vCrvCompo.back()->IsClosed())
         vCrvCompo.pop_back() ;
   }
  // abbellisco le curve trovate
   const double SILH_ARC_TOL = 0.1 ;
   const double SILH_ARC_FEA_MAX = 100. ;
   for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
      PolyArc PA ;
      if ( vCrvCompo[i]->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
         PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
         if ( ! IsNull( pTempCrv)  &&
              pTempCrv->FromPolyArc( PA)  &&
              pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)  &&
              pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
            vCrvCompo[i].Set( pTempCrv) ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetOptimalSfr( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrLoc, const Vector3d& vtTool,
                              double dDepth, double dElev, ISurfFlatRegion* pSfrSpiral, ISurfFlatRegion* pSfrZConst) const
{
  // controllo dei parametri
   if ( pSfrLoc == nullptr  ||  ! pSfrLoc->IsValid())
      return false ;
   pSfrSpiral->Clear() ;
   pSfrZConst->Clear() ;

   #if ENABLE_OPTIMAL_DEBUG
      for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
         int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vSrfLoc[i]->Clone()) ;
         m_pGeomDB->SetMaterial( _a, YELLOW) ;
      }
   #endif

  // versore utensile e di movimento longitudinali in frame locale
   Vector3d vtAxL = GetToLoc( vtTool, frSurf) ;
   Vector3d vtMoveL = vtAxL ;

  // costanti
   const double CLIPPING_ANGLE = 45. ;          // Angolo di clipping tra Spiral e ZConst
   const double TOL_SAMPLE = 1. ;               // Tolleranza di campionamento per collisioni
   const double EXTRA_XY = 2.5 * TOL_SAMPLE ;   // Espansione del Box in X e Y per griglia di campionamento

  // frame pianoXY
   Frame3d frXY ;
   Point3d ptC ; pSfrLoc->GetCentroid( ptC) ;
   if ( ! frXY.Set( ptC, pSfrLoc->GetNormVersor()))
      return false ;
  // considero il frame inverso
   Frame3d frXYInv = frXY ; frXYInv.Invert() ;

  // calcolo il Box della regione rispetto al frame XY invertito (quindi il box su XY locale alla pSfr)
   BBox3d BBoxLoc ;
   if ( ! pSfrLoc->GetBBox( frXYInv, BBoxLoc))
      return false ;
  // lo espendo
   BBoxLoc.Expand( EXTRA_XY, EXTRA_XY, 0.) ;
  // definisco il numero di punti lungo asse X e Y
   int nStepX = int( ceil( BBoxLoc.GetDimX() / TOL_SAMPLE)) ;
   int nStepY = int( ceil( BBoxLoc.GetDimY() / TOL_SAMPLE)) ;
   frXY.ChangeOrig( GetToGlob( BBoxLoc.GetMin(), frXY)) ;

  // definisco una griglia di <punto, movimento, vtN(s)> ( sempre in FrLoc)
   PNTUVVECTLIST lPntM ;   // per TestPath con collisioni (lista)
   INTVECTOR vIndBorder ;  // indici di bordo
   for ( int j = 0 ; j <= nStepY ; ++ j) {
      for ( int i = 0 ; i <= nStepX ; ++ i) {
         int nInd = i + j * ( nStepX + 1) ;
         Point3d ptTest = GetToGlob( Point3d( i * TOL_SAMPLE, j * TOL_SAMPLE, 0.), frXY) ;
         if ( i == 0  ||  j == 0  ||  i == nStepX  ||  j == nStepY)
            vIndBorder.push_back( nInd) ;
        // controtraslo i punti della lunghezza utensile
         ptTest.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
         lPntM.emplace_back( make_tuple( ptTest, 0., VCT3DVECTOR{V_NULL})) ;
      }
   }

  // effettuo verifica Collisione avanzata ( i versori normali sono solo quelli ad alzata massima dalle superfici)
   if ( ! pCAvTlStm->TestPointsAdv( lPntM, vtAxL, vtMoveL))
      return false ;

   #if ENABLE_OPTIMAL_DEBUG
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "_debug_grid") ;
      m_pGeomDB->SetStatus( nGrp, GDB_ST_ON) ;
      int nLyS = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLyS, "_spiral") ;
      m_pGeomDB->SetStatus( nLyS, GDB_ST_OFF) ;
      int nLyZC = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLyZC, "_zconst") ;
      m_pGeomDB->SetStatus( nLyZC, GDB_ST_OFF) ;
      int nLyN = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLyN, "_normals") ;
      m_pGeomDB->SetStatus( nLyN, GDB_ST_OFF) ;
   #endif

  // controllo dei versori normali di collisione per Marching Square
  // NB. viene definita una struttura con due booleani, il primo associato al Marching Square
  // per la superficie Spiral e il secondo per la superficie ZConst
   VECTORCOLLISIONSFR vCollision( ( nStepX + 1) * ( nStepY + 1)) ;
   int nInd = 0 ;
   double dCosClipping = cos( CLIPPING_ANGLE * DEGTORAD) ;
   for ( auto it = lPntM.begin() ; it != lPntM.end() ; ++ it) {
     // inserisco il punto di Test
      get<0>( vCollision[nInd].CollisionInfo) = get<0>( *it) ;
     // controllo se il punto è sulla frontiera del Box2d della griglia
      bool bOnBorder = ( find( vIndBorder.begin(), vIndBorder.end(), nInd) != vIndBorder.end()) ;
     // inserisco il parametro dU di salita del tool per evitare la collisione
      get<1>( vCollision[nInd].CollisionInfo) = ( bOnBorder ? INFINITO : get<1>( *it)) ;
     // inserisco i versori tangenti di collisione e valuto quale superficie ( Spiral o ZConst) è definita
      vCollision[nInd].bInSpiral = false ;
      vCollision[nInd].bInZConst = false ;
      for ( int nV = 0 ; nV < int( get<2>( *it).size()) ; ++ nV) {
         if ( ! bOnBorder) {
            double dAbsCos = abs( get<2>( *it)[nV] * vtAxL) ;
            if ( ! vCollision[nInd].bInSpiral)
               vCollision[nInd].bInSpiral = ( dAbsCos > dCosClipping + EPS_ANG_ZERO) ; // theta > ClippingAng
            if ( ! vCollision[nInd].bInZConst)
               vCollision[nInd].bInZConst = ( dAbsCos < dCosClipping + EPS_ANG_ZERO) ; // theta <= ClippingAng
         }
         get<2>( vCollision[nInd].CollisionInfo).push_back( get<2>( *it)[nV]) ;
      }
      #if ENABLE_OPTIMAL_DEBUG
         PtrOwner<IGeoPoint3d> pt( CreateGeoPoint3d()) ;
         pt->Set( get<0>( vCollision[nInd].CollisionInfo)) ;
         int _pS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyS, pt->Clone()) ;
         int _pZC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyZC, pt->Clone()) ;
         Color myColS = ( vCollision[nInd].bInSpiral ? BLUE : RED) ;
         Color myColZC = ( vCollision[nInd].bInZConst ? BLUE : RED) ;
         m_pGeomDB->SetMaterial( _pS, myColS) ;
         m_pGeomDB->SetMaterial( _pZC, myColZC) ;
         for ( int nV = 0 ; nV < int( get<2>( vCollision[nInd].CollisionInfo).size()) ; ++ nV) {
            PtrOwner<IGeoVector3d> vt( CreateGeoVector3d()) ;
            vt->Set( get<2>( vCollision[nInd].CollisionInfo)[nV]) ;
            vt->Translate( pt->GetPoint() - ORIG) ;
            int _vN = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLyN, vt->Clone()) ;
            m_pGeomDB->SetMaterial( _vN, Color( abs( vt->GetVector().x), abs( vt->GetVector().y), abs( vt->GetVector().z))) ;
         }
      #endif
      ++ nInd ;
   }

   ICRVCOMPOPOVECTOR vCrvSpiral, vCrvZConst ;
   int nThreadMax = thread::hardware_concurrency() ;
   if ( nThreadMax <= 1) {
     // recupero le curve di contorno per la superficie Spiral
      if ( ! MarchingSquares( vCollision, true, nStepX, nStepY, CLIPPING_ANGLE, vtAxL, vtMoveL, pCAvTlStm, vCrvSpiral))
         return false ;
     // recupero le curve di contorno per la superficie ZConst
      if ( ! MarchingSquares( vCollision, false, nStepX, nStepY, CLIPPING_ANGLE, vtAxL, vtMoveL, pCAvTlStm, vCrvZConst))
         return false ;
   }
   else {
      future<bool> vRes[2] ;
      vRes[0] = async( launch::async, &SurfFinishing::MarchingSquares, this, cref( vCollision), true, nStepX, nStepY, CLIPPING_ANGLE, cref( vtAxL), cref( vtMoveL), ref( pCAvTlStm), ref( vCrvSpiral)) ;
      vRes[1] = async( launch::async, &SurfFinishing::MarchingSquares, this, cref( vCollision), false, nStepX, nStepY, CLIPPING_ANGLE, cref( vtAxL), cref( vtMoveL), ref( pCAvTlStm), ref( vCrvZConst)) ;
      int nFin = 0 ;
      bool bOk = true ;
      while ( nFin < 2) {
         for ( int i = 0 ; i < 2 ; ++ i) {
            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
               bOk = vRes[i].get() && bOk ;
               ++ nFin ;
            }
         }
      }
      if ( ! bOk)
         return false ;
   }

  // costruisco la regione ZConst
   if ( ! vCrvZConst.empty()) {
      SurfFlatRegionByContours SfrMaker ;
      for ( int i = 0 ; i < int( vCrvZConst.size()) ; ++ i)
         SfrMaker.AddCurve( Release( vCrvZConst[i])) ;
      PtrOwner<ISurfFlatRegion> pSfrZC( SfrMaker.GetSurf()) ;
      if ( ! IsNull( pSfrZC)  &&  pSfrZC->IsValid()) {
         pSfrZConst->CopyFrom( pSfrZC) ;
         pSfrZConst->Translate( - vtAxL * ( m_TParams.m_dLen - dDepth)) ;
         if ( AreOppositeVectorApprox( pSfrZConst->GetNormVersor(), pSfrLoc->GetNormVersor()))
            pSfrZConst->Invert() ;
        // Offset di correzione per le regioni ZConst
         pSfrZConst->Offset( TOL_SAMPLE + EPS_SMALL, ICurve::OFF_FILLET) ;
        // Offset di correzione
         #if ENABLE_OPTIMAL_SOFT_DEBUG
            int _pSZC = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrZConst->Clone()) ;
            m_pGeomDB->SetMaterial( _pSZC, Color( 0., 1., 0., .65)) ;
         #endif
      }
   }
  // costruisco la regione Spiral
   if ( ! vCrvSpiral.empty()) {
      SurfFlatRegionByContours SfrMaker ;
      for ( int i = 0 ; i < int( vCrvSpiral.size()) ; ++ i)
         SfrMaker.AddCurve( Release( vCrvSpiral[i])) ;
      PtrOwner<ISurfFlatRegion> pSfrS( SfrMaker.GetSurf()) ;
      if ( ! IsNull( pSfrS)  &&  pSfrS->IsValid()) {
         pSfrSpiral->CopyFrom( pSfrS) ;
         pSfrSpiral->Translate( - vtAxL * ( m_TParams.m_dLen - dDepth)) ;
         if ( AreOppositeVectorApprox( pSfrSpiral->GetNormVersor(), pSfrLoc->GetNormVersor()))
            pSfrSpiral->Invert() ;
        // Offset di correzione per le regioni Spiral
         pSfrSpiral->Offset( - TOL_SAMPLE - EPS_SMALL, ICurve::OFF_FILLET) ;
         #if ENABLE_OPTIMAL_SOFT_DEBUG
            int _pSS = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrSpiral->Clone()) ;
            m_pGeomDB->SetMaterial( _pSS, Color( 1., 0., 0., .65)) ;
         #endif
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
                           const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
  // controllo che la regione sia definita correttamente
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;

  // aggiorno la ProgressBar del 5% per simulare l'inizio della funzione
   ExeProcessEvents( 5, 0) ;

  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
  // vettore dei percorsi da calcolare
   VECTORPATHS vPaths ;

  // definizione superfici piane di lavoro
   PtrOwner<ISurfFlatRegion> pSfrZConst( CreateSurfFlatRegion()) ;
   PtrOwner<ISurfFlatRegion> pSfrSpiral( CreateSurfFlatRegion()) ;
   PtrOwner<ISurfFlatRegion> pSfrLoc( CloneSurfFlatRegion( pSfr)) ;
   if ( IsNull( pSfrZConst)  ||  IsNull( pSfrSpiral)  ||
      IsNull( pSfrLoc)  ||  ! pSfrLoc->IsValid()  ||  ! pSfrLoc->ToLoc( frSurf))
      return false ;

  // calcolo le regioni Spiral e ZConst per la finitura
   if ( ! GetOptimalSfr( pCAvTlStm, vSrfLoc, frSurf, pSfrLoc, vtTool, dDepth, dElev, pSfrSpiral, pSfrZConst)) {
      m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
      return false ;
   }

  // ----------------------- Lavorazione Spiral -------------------------------
   if ( ! IsNull( pSfrSpiral)  &&  pSfrSpiral->IsValid()) {
     // se richiesto parametro SkipMaxDown, devo limitare questa superficie alla vera Silhouette
      bool bSkipMaxDown = true ;
      GetValInNotes( m_Params.m_sUserNotes, "SkipMaxDown", bSkipMaxDown) ;
      PtrOwner<ISurfFlatRegion> pSfrSil_real( CreateSurfFlatRegion()) ;
      if ( IsNull( pSfrSil_real))
         return false ;
      if ( bSkipMaxDown) {
         Frame3d frSfr ;
         Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
         if ( ! frSfr.Set( ptCenter, pSfr->GetNormVersor()))
            return false ;
         Frame3d frLvl0 = GetToLoc( frSfr, frSurf) ;
        // riduco la regione sulla Silhouette corretta
         pSfrSil_real.Set( GetSfrSilhouette( vSrfLoc, frLvl0, - dDepth)) ;
         if ( IsNull( pSfrSil_real)  ||  ! pSfrSil_real->IsValid()) {
            m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
            return false ;
         }
        // intersezione
         pSfrSil_real->Offset( - m_Params.m_dSideStep + 10 * EPS_SMALL, ICurve::OFF_FILLET) ;
         if ( ! IsNull( pSfrSil_real)  &&  pSfrSil_real->IsValid()) {
            pSfrSil_real->Translate( dDepth * frLvl0.VersZ()) ;
            if ( ! pSfrSpiral->Intersect( *pSfrSil_real))
               return false ;
         }
      }
      // le curve di finitura spiral devono stare sul bordo della regione trovata
      pSfrSpiral->Offset( m_Params.m_dSideStep, ICurve::OFF_FILLET) ;
     // mi assicuro di non uscire dalla superficie originale
      PtrOwner<ISurfFlatRegion> pSfrOverlap( pSfr->CreateOffsetSurf( m_Params.m_dOverlap, ICurve::OFF_FILLET)) ;
      if ( IsNull( pSfrOverlap))
         return false ;
      if ( ! IsNull( pSfrOverlap)  &&  pSfrOverlap->IsValid()) {
         pSfrOverlap->ToLoc( frSurf) ;
         pSfrSpiral->Intersect( *pSfrOverlap) ;
      }
      else
         pSfrSpiral->Clear() ;
     // lavoro ogni singolo Chunk singolarmente ( non estendo lati aperti per eveitare merge con gli stessi Chunks)
      for ( int nC = 0 ; nC < pSfrSpiral->GetChunkCount() ; ++ nC) {
        // recupero il Chunk come regione piana
         PtrOwner<ISurfFlatRegion> pSfrToWork( pSfrSpiral->CloneChunk( nC)) ;
         if ( IsNull( pSfrToWork)  ||  ! pSfrToWork->IsValid())
            return false ;
        // imposto i lati chiusi
         for ( int nCC = 0 ; nCC < pSfrToWork->GetChunkCount() ; ++ nCC) {
            for ( int nL = 0 ; nL < pSfrToWork->GetLoopCount( nCC) ; ++ nL) {
               for ( int nU = 0 ; nU < pSfrToWork->GetLoopCurveCount( nCC, nL) ; ++ nU)
                  pSfrToWork->SetCurveTempProp( nCC, nL, nU, 0, TEMP_PROP_CLOSE_EDGE) ;
            }
         }
        // lavorazione Spiral
         ICRVCOMPOPOVECTOR vpCrvs ;
         if ( ! CalcPocketing( pSfrToWork, m_Params.m_dSideStep, 0., m_Params.m_dSideStep, m_Params.m_dSideAngle,
                               POCKET_SPIRALIN, false, false, true, false, P_INVALID, nullptr, true, vpCrvs)) {
            m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
            return false ;
         }
        // ciclo sui percorsi ricavati risultanti
         double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
         for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
           // definisco un nuovo percorso (in locale)
            vPaths.resize( vPaths.size() + 1) ;
            vPaths.back().pCrvPath.Set( Release( vpCrvs[k])) ;

            vPaths.back().nType = SURFFIN_SUB_SPIRALIN ;
           // li correggo per non interferire con le superfici
            if ( pCAvTlStm != nullptr) {
              // approssimo la curva con una polilinea
               PolyLine PL ;
               if ( ! vPaths.back().pCrvPath->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
                  return false ;
              // eventuale aggiunta di punti per garantire max distanza
               const double MIN_DIST = 1. ;
               const double MAX_DIST = 50. ;
               double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
               if ( ! PL.AdjustForMaxSegmentLen( dDist))
                  return false ;
              // porto i dati geometrici in locale alle superfici
               Vector3d vtAxL = vtTool ;
               vtAxL.ToLoc( frSurf) ;
               Vector3d vtMoveL = vtAxL ;
              // traslo della lunghezza utensile diminuita dell'affondamento
               PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
              // eseguo CAv
               if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff))
                  return false ;
              // contro-traslo della lunghezza utensile
               PL.Translate( - vtAxL * m_TParams.m_dLen) ;
              // elimino i punti allineati
               PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
              // creo una curva composita a partire dalla polilinea
               PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
               if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
                  return false ;
              // sostituisco la vecchia curva con la nuova
               vPaths.back().pCrvPath.Set( pCompo) ;
            }
         }
      }
     // porto tutti i percorsi nel frame globale
      for ( int i = 0 ; i < int( vPaths.size()) ; ++ i) {
         #if ENABLE_OPTIMAL_SOFT_DEBUG
            int _n = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vPaths[i].pCrvPath->Clone()) ;
            m_pGeomDB->SetMaterial( _n, RED) ;
         #endif
         vPaths[i].pCrvPath->ToGlob( frSurf) ;
      }
   }

  // aggiorno la ProgressBar al 60%
   ExeProcessEvents( 5, 0) ;
   #if ENABLE_OPTIMAL_SOFT_DEBUG
     // disegno i percorsi per controllo
      int ___a = int( vPaths.size()) ;
      for ( int i = 0 ; i < int( vPaths.size()) ; ++ i) {
         int _n = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vPaths[i].pCrvPath->Clone()) ;
         m_pGeomDB->SetMaterial( _n, RED) ;

      }
   #endif

  // ----------------------- Lavorazione Zconst -------------------------------
   if ( ! IsNull( pSfrZConst)  &&  pSfrZConst->IsValid()) {
     // lavoro ogni singolo Chunk singolarmente ( non estendo lati aperti per evitare merge con gli stessi Chunks)
      for ( int nC = 0 ; nC < pSfrZConst->GetChunkCount() ; ++ nC) {
        // recupero il Chunk come regione piana
         PtrOwner<ISurfFlatRegion> pSfrToWork( pSfrZConst->CloneChunk( nC)) ;
         if ( IsNull( pSfrToWork)  ||  ! pSfrToWork->IsValid())
            return false ;
        // mi assicuro di non uscire dalla superficie originale
         PtrOwner<ISurfFlatRegion> pSfrOverlap( pSfr->CreateOffsetSurf( m_Params.m_dOverlap, ICurve::OFF_FILLET)) ;
         if ( IsNull( pSfrOverlap)  ||  ! pSfrOverlap->IsValid())
            continue ;
         if ( ! pSfrOverlap->ToLoc( frSurf)  ||  ! pSfrToWork->Intersect( *pSfrOverlap))
            return false ;
        // imposto i lati chiusi
         for ( int nCC = 0 ; nCC < pSfrToWork->GetChunkCount() ; ++ nCC) {
            for ( int nL = 0 ; nL < pSfrToWork->GetLoopCount( nCC) ; ++ nL) {
               for ( int nU = 0 ; nU < pSfrToWork->GetLoopCurveCount( nCC, nL) ; ++ nU)
                  pSfrToWork->SetCurveTempProp( nC, nL, nU, 0, TEMP_PROP_CLOSE_EDGE) ;
            }
         }
        // inizializzo la classe di calcolo delle silhouette
         CISURFTMPVECTOR vpStm ;  vpStm.reserve( vSrfLoc.size()) ;
        // scorro le superfici
         for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
           // recupero la superficie TriMesh e se valida la memorizzo
            const ISurfTriMesh* pStm = GetSurfTriMesh( vSrfLoc[i].Get()) ;
            if ( pStm != nullptr  &&  pStm->IsValid()  &&  pStm->GetTriangleCount() > 0)
                vpStm.emplace_back( pStm) ;
         }
         PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
         if ( IsNull( pCavParSilh)  ||
              ! pCavParSilh->SetDataForRegion( vpStm, pSfrToWork, m_TParams.m_dSideAng, m_TParams.m_dDiam,
                                               m_TParams.m_dCornRad, m_TParams.m_dMaxMat, GetOffsR(), SILH_SAMPLING, ANG_TOL_STD_DEG))
            return false ;
        // recupero le curve singole definite dal bordo della Silhouette
         vector<ICRVCOMPOPOVECTOR> vCrvCompo ;
         if ( ! CalcZConstSilCrv( pCavParSilh, vSrfLoc, frSurf, pSfrToWork, vtTool, dDepth, vCrvCompo)) {
            m_pMchMgr->SetLastError( 3126, "Error in SurfFinishing : Computing ZConst Curves failed") ;
            return false ;
         }
        // se ho delle curve, allora unisco i percorsi trovati
         if ( ! vCrvCompo.empty()) {
           // collego tra loro le curve trovate
            ICRVCOMPOPOVECTOR vCrv ;
            if ( ! CreateZConstPaths( pCAvTlStm, frSurf, vCrvCompo, vtTool, pSfrToWork, dDepth, vCrv)) {
               m_pMchMgr->SetLastError( 3127, "Error in SurfFinishing : Computing ZConst Paths failed") ;
               return false ;
            }
           // aggiungo i percorsi trovati
            for ( int i = 0 ; i < int( vCrv.size()) ; ++ i) {
               #if ENABLE_OPTIMAL_SOFT_DEBUG
                  int _n = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrv[i]->Clone()) ;
                  m_pGeomDB->SetMaterial( _n, GREEN) ;
               #endif
               vPaths.resize( vPaths.size() + 1) ;
               vPaths.back().pCrvPath.Set( Release( vCrv[i])) ;
               vPaths.back().nType = SURFFIN_SUB_ZIGZAG ;
              // in globale
               vPaths.back().pCrvPath->ToGlob( frSurf) ;
            }
         }
      }
   }

  // aggiorno la ProgressBar all' 80%
   ExeProcessEvents( 80, 0) ;

   #if ENABLE_OPTIMAL_SOFT_DEBUG
     // disegno i percorsi per controllo
      for ( int i = ___a ; i < int( vPaths.size()) ; ++ i) {
         int _n = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vPaths[i].pCrvPath->Clone()) ;
         m_pGeomDB->SetMaterial( _n, GREEN) ;
      }
   #endif

  // ordino i percorsi in base alla Zlocale
   if ( ! OrderOptimalPathsByZLoc( pSfr, vPaths))
      return false ;
  // aggiorno la ProgressBar all' 80%
   ExeProcessEvents( 90, 0) ;

  // aggiusto la regione a seconda dei parametri
   PtrOwner<ISurfFlatRegion> pSfrClass( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + m_Params.m_dOverlap, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrClass)  ||  ! pSfrClass->IsValid())
      return false ;
  // piano definito dalla pSfr
   Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
   Plane3d plSfr ;
   if ( ! plSfr.Set( ptCenter, vtTool))
      return false ;
  // inserisco i percorsi
   bool bStart = true ;
  // ciclo sulle curve risultanti
   for ( int k = 0 ; k < int( vPaths.size()) ; ++ k) {
     // se la curva non è valida, passo alla successiva
      if ( IsNull( vPaths[k].pCrvPath)  ||  ! vPaths[k].pCrvPath->IsValid())
         continue ;
     // determino in che piano di partenza e il piano di arrivo se ZConst
      int nStartPlane = 0 ;
      int nEndPlane = 0 ;
      if ( vPaths[k].nType == SURFFIN_SUB_Z_CONST) {
         nStartPlane = vPaths[k].pCrvPath->GetTempProp( 0) ;
         nEndPlane = vPaths[k].pCrvPath->GetTempProp( 1) ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = vPaths[k].pCrvPath->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = vPaths[k].pCrvPath->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
        // se prima entità
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // controllo che tale punto sia al di fuori della regione piana
            if ( vPaths[k].nType == SURFFIN_SUB_Z_CONST) {
               bool bIsInside = false ;
               if ( IsPointInsideSurfFr( ptP1 + vtTool * ( m_Params.m_dSideStep * nStartPlane), pSfrClass, EPS_SMALL, bIsInside)  &&  ! bIsInside)
                  ptP1 = ptStart ;
            }
            else {
               bool bIsInside = false ;
               if ( IsPointInsideSurfFr( ProjectPointOnPlane( ptP1, plSfr), pSfrClass, EPS_SMALL, bIsInside)  &&  ! bIsInside)
                  ptP1 = ptStart ;
            }
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
          if ( pCurve->GetType() == CRV_LINE) {
             ICurveLine* pLine = GetCurveLine( pCurve) ;
             Point3d ptP3 = pLine->GetEnd() ;
             Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
             SetFeed( GetRightFeed( vtMove, vtTool)) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
          else if ( pCurve->GetType() == CRV_ARC) {
             ICurveArc* pArc = GetCurveArc( pCurve) ;
             Point3d ptCen = pArc->GetCenter() ;
             double dAngCen = pArc->GetAngCenter() ;
             Vector3d vtN = pArc->GetNormVersor() ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
             SetFeed( GetFeed()) ;
             if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // controllo che tale punto sia al di fuori della regione piana
            bool bIsInside = false ;
            if ( IsPointInsideSurfFr( ptP1 + vtTool * ( m_Params.m_dSideStep * nStartPlane), pSfrClass, EPS_SMALL, bIsInside))
               ptP1 = ptEnd ;
           // se ultima uscita globale del percorso
            if ( k == int( vPaths.size()) - 1) {
              // aggiungo LeadOut
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
                  return false ;
               }
              // aggiungo retroazione finale
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, nEndPlane * m_Params.m_dSideStep, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
           // altrimenti
            else {
              // determino elevazione su fine uscita
               double dEndElev ;
               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
               dEndElev -= ( ptP1 - ptEnd) * vtTool ;
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }

  // aggiorno la ProgressBar all' 100%
   ExeProcessEvents( 100, 0) ;
   return true ;

}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                              const ICurveComposite* pCrvCompo, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
{
  // controllo che la curva sia valida
   if ( pCrvCompo == nullptr  ||  ! pCrvCompo->IsValid())
      return false ;

  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // definisco un sistema di riferimento locale alla curva
   Point3d ptStart ; pCrvCompo->GetStartPoint( ptStart) ;
   Frame3d frLoc ;
   if ( ! frLoc.Set( ptStart, vtTool))
      return false ;
  // definisco il frame inverso per il calcolo del Box3d
   Frame3d frLocInv = frLoc ;
   if ( ! frLocInv.Invert())
      return false ;

  // definisco variabili globali
   BBox3d BBox3Loc ;                // box totale delle superici rispetto a frLoc
   ISURFTMPOVECTOR vpStm ;          // superfici TriMesh selezionate in globale
   ICRVCOMPOPOVECTOR vCrvToProj ;   // vettore delle curve da proiettare sulla superficie

  // scorro il vettore di superfici selezionate
   for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
     // porto la supercicie nel riferimento globale come TriMesh
      PtrOwner<ISurfTriMesh> pStm( CloneSurfTriMesh( GetSurfTriMesh( vSrfLoc[i].Get()))) ;
      if ( IsNull( pStm)  ||  ! pStm->IsValid()  ||  ! pStm->ToGlob( frSurf))
         return false ;
     // calcolo il box rispetto a frLoc e sommo i contributi
      BBox3d BBox ;
      if ( ! pStm->GetBBox( frLocInv, BBox))
         return false ;
      BBox3Loc.Add( BBox) ;
     // memorizzo la superficie nel vettore
      vpStm.emplace_back( Release( pStm)) ;
   }

  // recupero flag per saltare parti a massimo affondamento
   bool bSkipMaxDown = true ;
   GetValInNotes( m_Params.m_sUserNotes, "SkipMaxDown", bSkipMaxDown) ;
   if ( bSkipMaxDown) {
     // definisco i dati di calcolo della Silhouette
      const double SILH_TOL = 1.0 ;
      CISURFTMPVECTOR vSurf ; vSurf.reserve( vpStm.size()) ;
      for ( int i = 0; i < int( vpStm.size()) ; ++ i)
         vSurf.emplace_back( vpStm[i]) ;
      PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
      if ( IsNull( pCavParSilh)  ||  ! pCavParSilh->SetData( vSurf, frLoc, SILH_TOL))
         return false ;
      // recupero il vettore di PolyLine della silhouette
      POLYLINEVECTOR vPL ;
      if ( ! pCavParSilh->GetSilhouette( BBox3Loc.GetMin().z , vPL))
         return false ;
     // creo la regione piana dalle PolyLine ricavate dalla Silhouette
      SurfFlatRegionByContours SfrMaker ;
      for ( auto& PL : vPL) {
        // recupero la curva dalla silhouette
         PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
         if ( IsNull( pSilCrv))
            return false ;
         pSilCrv->FromPolyLine( PL) ;
        // approssimo con archi
         const double SILH_ARC_TOL = 0.1 * SILH_TOL ;
         const double SILH_ARC_FEA_MAX = 100. ;
         PolyArc PA ;
         if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
            PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
            if ( ! IsNull( pTempCrv)  &&
                 pTempCrv->FromPolyArc( PA)  &&
                 pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)  &&
                 pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
               pSilCrv.Set( pTempCrv) ;
         }
        // aggiungo per regione
         if ( ! SfrMaker.AddCurve( Release( pSilCrv))) {
            m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
            return false ;
         }
      }
     // definisco la regione piana
      PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
      if ( ! IsNull( pSfrSil)  &&  pSfrSil->IsValid()) {
        // Offset alla Silhouette
         double dPockRadOffs = m_TParams.m_dDiam - m_Params.m_dSideStep - m_Params.m_dOverlap ;
         pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
        // porto la curva e la Silhouette nel frame locale per classificazione ( alla stezza zLoc)
         PtrOwner<ICurveComposite> pCrvCompoCL( CloneCurveComposite( pCrvCompo)) ;
         if ( IsNull( pCrvCompoCL)  ||  ! pCrvCompoCL->IsValid())
            return false ;
         pCrvCompoCL->Translate( BBox3Loc.GetMin().z * vtTool) ;
         pCrvCompoCL->ToLoc( frLoc) ;
         pSfrSil->ToLoc( frLoc) ;
        // classifico
         CRVCVECTOR ccClass ;
         if ( pSfrSil->GetCurveClassification( *pCrvCompoCL, EPS_SMALL, ccClass)) {
            for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
              // se tratto di curva interno
               if ( ccClass[i].nClass != CRVC_OUT) {
                 // recupero la curva
                  PtrOwner<ICurve> pCrvInt( pCrvCompo->CopyParamRange( ccClass[i].dParS, ccClass[i].dParE)) ;
                  if ( ! IsNull( pCrvInt)  &&  pCrvInt->IsValid())
                     vCrvToProj.emplace_back( ConvertCurveToComposite( Release( pCrvInt))) ;
               }
            }
         }
      }
   }
   else
      vCrvToProj.emplace_back( CloneCurveComposite( pCrvCompo)) ;

  // per ogni tratto di curva ricavato
   for ( int i = 0 ; i < int( vCrvToProj.size()) ; ++ i) {
     // se curva non valida, passo alla successiva
      if ( vCrvToProj[i] == nullptr  ||  ! vCrvToProj[i]->IsValid())
         continue ;
     // recupero la PolyLinea associata alla curva
      PolyLine PL ;
      if ( ! vCrvToProj[i]->ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
         return false ;
     // recupero la distanza di traslazione della Polyline e la traslo
      PL.Translate( -dDepth * vtTool) ;
     // calcolo direzione di allontanamento dalle superfici
      const double MIN_DIST = 1. ;
      const double MAX_DIST = 50. ;
      double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
      if ( ! PL.AdjustForMaxSegmentLen( dDist))
         return false ;
     // porto la polyline nel frame delle superfici
      Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
      PL.ToLoc( frSurf) ;
     // porto i punti dal tip al naso mandrino
      PL.Translate( vtToolL * m_TParams.m_dLen) ;
     // eseguo il test del percorso
      if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtToolL, vtToolL, m_Params.m_dApprox))
         return false ;
     // traslo della lunghezza utensile
      PL.Translate( - vtToolL * m_TParams.m_dLen) ;
     // riporto la polyline nel frame globale
      PL.ToGlob( frSurf) ;
     // elimino i punti allineati
      PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
     // recupero la curva composita dalla PolyLine
      PtrOwner<ICurveComposite> pCrvPath( CreateCurveComposite()) ;
      if ( IsNull( pCrvPath)  ||  ! pCrvPath->FromPolyLine( PL)  ||  ! pCrvPath->IsValid())
         return false ;

     // ciclo sulle curve elementari
      bool bStart = true ;
      int nMaxInd = pCrvPath->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pCrvPath->GetCurve( i) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
         // se prima entità
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
            double dStartOnExtr = vtStart * vtTool ;
            if ( dStartOnExtr > 0) {
               vtStart -= dStartOnExtr * vtTool ;
               vtStart.Normalize() ;
            }
           // determino normale della superficie sul punto iniziale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
               Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino inizio attacco
            Point3d ptP1 ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione inizio attacco per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
               return false ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dElev ;
            dStElev -= ( ptP1 - ptStart) * vtTool ;
           // se inizio, approccio globale al punto iniziale
            if ( bStart) {
               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
                  return false ;
               }
               bStart = false ;
            }
           // altrimenti, approccio di collegamento
            else {
               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
                  return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
               return false ;
            }
         }
        // elaborazioni sulla curva corrente (sempre un segmento di retta)
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         if ( pLine == nullptr)
            return false ;
         Point3d ptP3 = pLine->GetEnd() ;
         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
         SetFeed( GetRightFeed( vtMove, vtTool)) ;
         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
        // se ultima entità
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
           // vettore tangente finale non deve scendere rispetto a estrusione
            double dEndOnExtr = vtEnd * vtTool ;
            if ( dEndOnExtr < 0) {
               vtEnd -= dEndOnExtr * vtTool ;
               vtEnd.Normalize() ;
            }
           // determino normale della superficie sul punto finale
            Vector3d vtNorm ;
            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
               Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
                  vtNorm = V_NULL ;
            }
           // determino fine uscita
            Point3d ptP1 ;
            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
               return false ;
           // eventuale correzione fine uscita per evitare interferenze
            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
               return false ;
           // aggiungo uscita
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
               return false ;
            }
           // determino elevazione su fine uscita
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
           // altrimenti aggiungo retrazione finale
            if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
               m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
               return false ;
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
   SetFlag( 1) ;
  // se sopra attacco c'è spazio per sicurezza o approccio
   double dSafeDist = dSafeZ ;
   if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
     // se distanza di sicurezza minore di distanza di inizio
      if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
        // 1 -> punto sopra inizio
         Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
         if ( AddRapidStart( ptP1) == GDB_ID_NULL)
            return false ;
      }
      else {
        // 1a -> punto sopra inizio
         Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
         Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ;
         if ( ( AddRapidStart( ptP1a) == GDB_ID_NULL))
            return false ;
        // 1b -> punto appena sopra inizio
         if ( ( dElev + dAppr) > EPS_SMALL) {
            SetFlag( 0) ;
            if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
               return false ;
         }
      }
     // affondo al punto iniziale
      SetFlag( 0) ;
      SetFeed( GetTipFeed()) ;
      if ( AddLinearMove( ptP) == GDB_ID_NULL)
         return false ;
   }
   else {
     // affondo diretto al punto iniziale
      SetFlag( 0) ;
      if ( AddRapidStart( ptP) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
  // se sopra attacco c'è spazio per approccio
   if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
     // 1b -> punto appena sopra inizio
      Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
      if ( ( dElev + dAppr) > EPS_SMALL) {
         SetFlag( 0) ;
         if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
            return false ;
      }
     // affondo al punto iniziale
      SetFlag( 0) ;
      SetFeed( GetTipFeed()) ;
      if ( AddLinearMove( ptP) == GDB_ID_NULL)
         return false ;
   }
   else {
     // affondo diretto al punto iniziale
      SetFlag( 0) ;
      if ( AddRapidMove( ptP) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
  // se sopra uscita c'è spazio per approccio
   if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
     // 4 -> movimento di risalita sopra il punto finale
      SetFeed( GetEndFeed()) ;
      Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
      if ( AddLinearMove( ptP4) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
  // se sopra uscita c'è spazio per sicurezza o approccio
   double dSafeDist = dSafeZ ;
   if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
      if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
        // 4 -> movimento di risalita sopra il punto finale
         SetFeed( GetEndFeed()) ;
         Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
         if ( AddLinearMove( ptP4) == GDB_ID_NULL)
            return false ;
      }
      else {
        // 4a -> movimento di risalita appena sopra il punto finale
         Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
         if ( dElev + dAppr > EPS_SMALL) {
            SetFeed( GetEndFeed()) ;
            if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
               return false ;
         }
        // 4b -> movimento di risalita sopra il punto finale
         Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
         if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
int
SurfFinishing::GetLeadInType( void) const
{
   if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
      return SURFFIN_LI_NONE ;
   return m_Params.m_nLeadInType ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const
{
  // Assegno tipo e parametri
   int nType = GetLeadInType() ;
   double dTang = m_Params.m_dLiTang ;
   double dPerp = m_Params.m_dLiPerp ;
  // Calcolo punto iniziale
   switch ( nType) {
   case SURFFIN_LI_NONE :
      ptP1 = ptStart ;
      return true ;
   case SURFFIN_LI_LINEAR :
   case SURFFIN_LI_TANGENT :
      {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, -1) ;
         if ( vtPerp * vtNorm < -EPS_ZERO)
            vtPerp.Invert() ;
         ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp ;
      }
      return true ;
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs)
{
  // Se inizio e fine coincidono, non devo fare alcunchè
   if ( AreSamePointApprox( ptP1, ptStart))
      return true ;
  // Assegno il tipo
   int nType = GetLeadInType() ;
  // Eseguo a seconda del tipo
   switch ( nType) {
   case SURFFIN_LI_NONE :
      return true ;
   case SURFFIN_LI_LINEAR :
      return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
   case SURFFIN_LI_TANGENT :
      PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, -vtStart, vtTool)) ;
      if ( IsNull( pCrv))
         return false ;
      pCrv->Invert() ;
      return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
int
SurfFinishing::GetLeadOutType( void) const
{
   if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        m_Params.m_nLeadOutType  != SURFFIN_LO_AS_LI)
      return SURFFIN_LO_NONE ;
   return m_Params.m_nLeadOutType ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const
{
  // Assegno tipo e parametri
   int nType = GetLeadOutType() ;
   double dTang = m_Params.m_dLoTang ;
   double dPerp = m_Params.m_dLoPerp ;
  // se uscita come ingresso
   if ( nType == SURFFIN_LO_AS_LI) {
      int nLiType = GetLeadInType() ;
      switch ( nLiType) {
      case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ;
      case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ;
      default : nType = SURFFIN_LO_NONE ; break ;
      }
      dTang = m_Params.m_dLiTang ;
      dPerp = m_Params.m_dLiPerp ;
   }
  // Calcolo punto finale
   switch ( nType) {
   case SURFFIN_LO_NONE :
      ptP1 = ptEnd ;
      return true ;
   case SURFFIN_LO_LINEAR :
   case SURFFIN_LO_TANGENT :
      {
        // calcolo punto finale dell'uscita
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, -1) ;
         if ( vtPerp * vtNorm < -EPS_ZERO)
            vtPerp.Invert() ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
      }
      return true ;
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
SurfFinishing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs)
{
  // Se inizio e fine coincidono, non devo fare alcunchè
   if ( AreSamePointApprox( ptEnd, ptP1))
      return true ;
  // Assegno tipo e parametri
   int nType = GetLeadOutType() ;
  // se uscita come ingresso
   if ( nType == SURFFIN_LO_AS_LI) {
      int nLiType = GetLeadInType() ;
      switch ( nLiType) {
      case SURFFIN_LI_LINEAR : nType = SURFFIN_LO_LINEAR ; break ;
      case SURFFIN_LI_TANGENT : nType = SURFFIN_LO_TANGENT ; break ;
      default : nType = SURFFIN_LO_NONE ; break ;
      }
   }
  // eseguo a seconda del tipo
   switch ( nType) {
   case SURFFIN_LO_NONE :
      return true ;
   case SURFFIN_LO_LINEAR :
      return ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
   case SURFFIN_LO_TANGENT :
     // inserisco uscita
      PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ;
      if ( IsNull( pCrv))
         return false ;
     // assegno direzione finale dell'uscita
      Vector3d vtDirF ;
      if ( ! pCrv->GetEndDir( vtDirF))
         return false ;
     // emetto movimento
      return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
                                 const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, Point3d& ptP1) const
{
  // porto i punti e il versore nel riferimento superficie
   Point3d ptStartL = GetToLoc( ptStart, frSurf) ;
   Point3d ptEndL = GetToLoc( ptEnd, frSurf) ;
   Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
  // porto i punti dal tip al naso mandrino
   ptStartL += vtToolL * m_TParams.m_dLen ;
   ptEndL += vtToolL * m_TParams.m_dLen ;
  // verifico che il movimento non interferisca con la superficie
   PNTULIST lstPntU{ { ptStartL, 0}, { ptEndL, 1}} ;
   if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtToolL, m_Params.m_dApprox, 0))
      return false ;
  // cerco l'ultimo punto non spostato per evitare collisione
   bool bFound = false ;
   auto currPU = lstPntU.begin() ;
   while ( ! bFound  &&  currPU != lstPntU.end()) {
      auto nextPU = next( currPU) ;
      if ( nextPU == lstPntU.end()  ||  nextPU->second > m_Params.m_dApprox){
         bFound = true ;
         ptP1 = GetToGlob( currPU->first - vtToolL * m_TParams.m_dLen, frSurf) ;
      }
      currPU = nextPU ;
   }
   return bFound ;
}

//----------------------------------------------------------------------------
bool
SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
                                        const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const
{
  // porto il punto e il versore nel riferimento superficie
   Point3d ptToolL = GetToLoc( ptTool, frSurf) ;
   Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
  // porto i punti dal tip al naso mandrino
   ptToolL += vtToolL * m_TParams.m_dLen ;
  // affondo di poco il punto per ricavare ultima superficie di contatto e sua normale
   double dMove ;
   Vector3d vtNormL ;
   if ( ! pCAvTlStm->TestPosition( ptToolL - vtToolL, vtToolL, vtToolL, dMove, &vtNormL)  ||  dMove < EPS_SMALL)
      return false ;
  // porto la normale in globale
   vtNorm = GetToGlob( vtNormL, frSurf) ;
   return true ;
}

//----------------------------------------------------------------------------
double
SurfFinishing::GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const
{
  // Determino i versori
   Vector3d vtM = vtMove ;
   vtM.Normalize() ;
   Vector3d vtT = vtTool ;
   vtT.Normalize() ;
  // Angolo tra movimento e versore utensile
   double dCosMove = vtM * vtT ;
  // Se l'utensile non ha movimento significativo di punta, si restituisce la feed standard
   if ( dCosMove > - COS_ORTO_ANG_SMALL)
      return GetFeed() ;
  // Altrimenti non si deve superare la massima velocità di punta prevista
   return min( GetFeed(), GetTipFeed() / abs( dCosMove)) ;
}

//----------------------------------------------------------------------------
double
SurfFinishing::GetRadiusForStartEndElevation( void) const
{
   const double DELTA_ELEV_RAD = 4.0 ; 
   double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ;
   return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}