//----------------------------------------------------------------------------
//  EgalTech 2017-2023
//----------------------------------------------------------------------------
// File : PocketingNT.cpp         Data : 17.12.23          Versione : 2.5l3
// Contenuto : Implementazione gestione svuotature.
//
//
//
// Modifiche : 04.02.17 DS Creazione modulo.
//             24.02.22 DS Corretta ed estesa VerifyPathFromBottom.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "PocketingNT.h"
#include "OperationConst.h"
#include "MachiningConst.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkBiArcs.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkOffsetCurve.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkPolygonElevation.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkDistPointSurfFr.h"
#include <algorithm>



using namespace std ;

//------------------------------ Errors --------------------------------------
// 2401 = "Error in PocketingNT : UpdateToolData failed"
// 2402 = "Error in PocketingNT : Open Contour"
// 2403 = "Error in PocketingNT : Contour Not Flat"
// 2404 = "Error in PocketingNT : Tool Not Perpendicular to Flat Area"
// 2405 = "Error in PocketingNT : Empty RawBox"
// 2406 = "Error in PocketingNT : Depth not computable"
// 2408 = "Error in PocketingNT : Entity GetElevation"
// 2409 = "Error in PocketingNT : missing aggregate from bottom"
// 2410 = "Error in PocketingNT : path too far from part sides"
// 2411 = "Error in PocketingNT : toolpath allocation failed"
// 2412 = "Error in PocketingNT : Offset not computable"
// 2413 = "Error in PocketingNT : Toolpath not computable"
// 2414 = "Error in PocketingNT : Approach not computable"
// 2415 = "Error in PocketingNT : LeadIn not computable"
// 2416 = "Error in PocketingNT : LeadOut not computable"
// 2417 = "Error in PocketingNT : Retract not computable"
// 2418 = "Error in PocketingNT : Link not computable"
// 2419 = "Error in PocketingNT : Linear Approx not computable"
// 2420 = "Error in PocketingNT : Return toolpath not computable"
// 2421 = "Error in PocketingNT : Chaining failed"
// 2422 = "Error in PocketingNT : Tool MaxMaterial too small (xxx)"
// 2423 = "Error in PocketingNT : axes values not calculable"
// 2424 = "Error in PocketingNT : outstroke xxx"
// 2425 = "Error in PocketingNT : link movements not calculable"
// 2426 = "Error in PocketingNT : link outstroke xxx"
// 2427 = "Error in PocketingNT : post apply not calculable"
// 2428 = "Error in PocketingNT : Tool loading failed"
// 2429 = "Error in PocketingNT : machining depth (xxx) bigger than MaxDepth (yyy)"
// 2430 = "Error in PocketingNT : adjust open edges failed"
// 2431 = "Error in PocketingNT : LeadIn with Mill NoTip in material"
// 2432 = "Error in PocketingNT : Mirror for Double calculation failed"
// 2451 = "Warning in PocketingNT : Skipped entity (xx)"
// 2452 = "Warning in PocketingNT : No machinable pocket"
// 2453 = "Warning in PocketingNT : Tool name changed (xx)"
// 2454 = "Warning in PocketingNT : Tool data changed (xx)"
// 2455 = "Warning in PocketingNT : skipped Path too short"
// 2456 = "Warning in PocketingNT : machining step too small (xx)"
// 2457 = "Warning in PocketingNT : machining step (xxx) bigger than MaxMaterial (yyy)"
// 2458 = "Warning in PocketingNT : machining depth (xxx) bigger than MaxMaterial (yyy)"

//----------------------------------------------------------------------------
static string KEY_OPEN = "OPEN" ;
static string KEY_THICK = "THICK" ;
static int LINK_CURVE_PROP = -3 ;

//----------------------------------------------------------------------------
#if POCKETING_NT == 1
   USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), PocketingNT) ;
#endif

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

//----------------------------------------------------------------------------
PocketingNT*
PocketingNT::Clone( void) const
{
  // alloco oggetto
   PocketingNT* pPock = new(nothrow) PocketingNT ;
  // eseguo copia dei dati
   if ( pPock != nullptr) {
      try {
         pPock->m_vId = m_vId ;
         pPock->m_pMchMgr = m_pMchMgr ;
         pPock->m_nPhase = m_nPhase ;
         pPock->m_Params = m_Params ;
         pPock->m_TParams = m_TParams ;
         pPock->m_dTHoldBase = m_dTHoldBase ;
         pPock->m_dTHoldLen = m_dTHoldLen ;
         pPock->m_dTHoldDiam = m_dTHoldDiam ;
         pPock->m_nStatus = m_nStatus ;
         pPock->m_nPockets = m_nPockets ;
         pPock->m_bTiltingTab = m_bTiltingTab ;
         pPock->m_vtTiltingAx = m_vtTiltingAx ;
         pPock->m_bAboveHead = m_bAboveHead ;
         pPock->m_bAggrBottom = m_bAggrBottom ;
         pPock->m_bOpenOutRaw = m_bOpenOutRaw ;
         pPock->m_dOpenMinSafe = m_dOpenMinSafe ;
      }
      catch( ...) {
         delete pPock ;
         return nullptr ;
      }
   }
  // ritorno l'oggetto
   return pPock ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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) {
      string sTmp = m_Params.ToString( i) ;
      if ( ! IsEmptyOrSpaces( sTmp))
         sOut += sTmp + szNewLine ;
   }
   for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
      string sTmp = m_TParams.ToString( i) ;
      if ( ! IsEmptyOrSpaces( sTmp))
         sOut += sTmp + szNewLine ;
   }
   sOut += KEY_NUM + EQUAL + ToString( m_nPockets) + szNewLine ;
   sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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) {
         string sParam = m_Params.ToString( i) ;
         if ( ! sParam.empty())
            vString[++k] = sParam ;
      }
      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_nPockets, vString[++k]))
         return false ;
      if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
         return false ;
      vString.resize( k + 1) ;
   }
   catch( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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_nPockets))
            return false ;
      }
      else if ( sKey == KEY_STAT) {
         if ( ! FromString( sVal, m_nStatus))
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
PocketingNT::PocketingNT( 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_dMaxHelixRad = INFINITO ;
   m_nStatus = MCH_ST_TO_VERIFY ;
   m_nPockets = 0 ;
   m_bTiltingTab = false ;
   m_bAboveHead = true ;
   m_bAggrBottom = false ;
   m_bOpenOutRaw = false ;
   m_dOpenMinSafe = 0 ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::Prepare( const string& sMillName)
{
  // 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 PocketingData* pDdata = GetPocketingData( pMMgr->GetMachining( sMillName)) ;
   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
PocketingNT::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 ;
   case MPA_TOOLINVERT :
      if ( bVal != m_Params.m_bToolInvert)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bToolInvert = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::SetParam( int nType, int nVal)
{
   switch ( nType) {
   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 ;
   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 ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_SPEED :
      if ( ! m_TParams.VerifySpeed( dVal))
         return false ;
      if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dSpeed = dVal ;
      return true ;
   case MPA_FEED :
      if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dFeed = dVal ;
      return true ;
   case MPA_STARTFEED :
      if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartFeed = dVal ;
      return true ;
   case MPA_ENDFEED :
      if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEndFeed = dVal ;
      return true ;
   case MPA_TIPFEED :
      if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTipFeed = dVal ;
      return true ;
   case MPA_OFFSR :
      if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
         dVal = UNKNOWN_PAR ;
      if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOffsR = dVal ;
      return true ;
   case MPA_OFFSL :
      if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
         dVal = UNKNOWN_PAR ;
      if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOffsL = 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 ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartPos = dVal ;
      return true ;
   case MPA_STEP :
      if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStep = dVal ;
      return true ;
   case MPA_SIDESTEP :
      if ( abs( dVal - m_Params.m_dSideStep) > EPS_MACH_LEN_PAR)
         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_LIELEV :
      if ( abs( dVal - m_Params.m_dLiElev) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiElev = 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_EPICYCLESRAD :
      if ( abs( dVal - m_Params.m_dEpicyclesRad) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEpicyclesRad = dVal ;
      return true ;
   case MPA_EPICYCLESDIST :
      if ( abs( dVal - m_Params.m_dEpicyclesDist) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEpicyclesDist = dVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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
PocketingNT::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 (tutte curve o tutte facce)
   int nType = GEO_NONE ;
   for ( const auto& Id : vIds) {
     // test sull'entità
      int nSubs ;
      if ( ! VerifyGeometry( Id, nSubs, nType)) {
         string sInfo = "Warning in PocketingNT : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2451, 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()  ||  vIds.empty()) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::Preview( bool bRecalc)
{
  // reset numero percorsi di svuotatura generati
   m_nPockets = 0 ;

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

  // 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 ;
   }

  // aggiorno dati geometrici dell'utensile
   if ( ! UpdateToolData()) {
      m_pMchMgr->SetLastError( 2401, "Error in PocketingNT : UpdateToolData failed") ;
      return false ;
   }

  // 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( 2428, "Error in PocketingNT : 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( 2421, "Error in PocketingNT : Chaining failed") ;
      return false ;
   }

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

  // lavoro ogni singola regione piana
   int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
   while ( nPathId != GDB_ID_NULL) {
      if ( ! ProcessPath( nPathId, nPvId, GDB_ID_NULL))
         return false ;
      nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::Apply( bool bRecalc, bool bPostApply)
{
  // reset numero percorsi di svuotatura generati
   int nCurrPockets = m_nPockets ;
   m_nPockets = 0 ;

  // reset raggio massimo attacco ad elica nel caso di cerchi
   m_dMaxHelixRad = INFINITO ;

  // 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( 2401, "Error in PocketingNT : UpdateToolData failed") ;
      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_nPockets = nCurrPockets ;
      string sLog = string( "PocketingNT 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( 2428, "Error in PocketingNT : 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) ;

  // 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) ;

  // elimino eventuale gruppo geometria simmetrica per lavorazione in doppio
   int nDblId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_DBL) ;
   if ( nDblId != GDB_ID_NULL) {
      m_pGeomDB->Erase( nDblId) ;
      nDblId = GDB_ID_NULL ;
   }

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

  // lavoro ogni singola catena
   bool bOk = true ;
   int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
   while ( nPathId != GDB_ID_NULL) {
      if ( ! ProcessPath( nPathId, GDB_ID_NULL, nClId))
         bOk = false ;
      nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
   }
   if ( ! bOk)
      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 ;

  // se lavorazione in doppio, aggiungo geometria della parte simmetrica
   if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
      m_pMchMgr->SetLastError( 2432, "Error in PocketingNT : Mirror for Double calculation failed") ;
      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(), "PocketingNT apply done") ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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_nPockets == 0) {
      m_pMchMgr->SetWarning( 2452, "Warning in PocketingNT : No machinable pocket") ;
      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( 2423, "Error in PocketingNT : axes values not calculable") ;
      else
         m_pMchMgr->SetLastError( 2424, "Error in PocketingNT : 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( 2425, "Error in PocketingNT : link movements not calculable") ;
      else
         m_pMchMgr->SetLastError( 2426, "Error in PocketingNT : 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( 2427, sErr) ;
      else
         m_pMchMgr->SetLastError( 2427, "Error in PocketingNT : post apply not calculable") ;
      return false ;
   }

   return true ;
}

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

//----------------------------------------------------------------------------
bool
PocketingNT::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_POCKETING ;
      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 ;
   case MPA_SUBTYPE :
      nVal = m_Params.m_nSubType ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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_OFFSL :
      dVal = GetOffsL() ;
      return true ;
   case MPA_STARTPOS :
      dVal = m_Params.m_dStartPos ;
      return true ;
   case MPA_STEP :
      dVal = m_Params.m_dStep ;
      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_LIELEV :
      dVal = m_Params.m_dLiElev ;
      return true ;
   case MPA_LOTANG :
      dVal = m_Params.m_dLoTang ;
      return true ;
   case MPA_EPICYCLESRAD :
      dVal = m_Params.m_dEpicyclesRad ;
      return true ;
   case MPA_EPICYCLESDIST :
      dVal = m_Params.m_dEpicyclesDist ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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&
PocketingNT::GetToolData( void) const
{
   return m_TParams ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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 PocketingNT : tool name changed (" +
                     m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
      m_pMchMgr->SetWarning( 2453, sInfo) ;
      m_Params.m_sToolName = m_TParams.m_sName ;
   }
   if ( bChanged) {
      string sInfo = "Warning in PocketingNT : tool data changed (" +
                     m_Params.m_sToolName + ")" ;
      m_pMchMgr->SetWarning( 2454, sInfo) ;
   }
  // se definito parametro di ritorno, lo assegno
   if ( pbChanged != nullptr)
      *pbChanged = bChanged ;
   return true ;
}

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

//----------------------------------------------------------------------------
bool
PocketingNT::VerifyGeometry( SelData Id, int& nSubs, int& nType)
{
  // ammessi : curve, testi, facce di trimesh o regioni
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   if ( pGObj == nullptr)
      return false ;
  // se ammesse curve ed è tale
   if ( ( nType == GEO_NONE  ||  nType == GEO_CURVE)  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
      nType = GEO_CURVE ;
      const ICurve* pCurve = nullptr ;
     // se direttamente la curva
      if ( Id.nSub == SEL_SUB_ALL) {
         pCurve = ::GetCurve( pGObj) ;
         if ( pCurve == nullptr)
            return false ;
         if ( pCurve->GetType() == CRV_COMPO)
            nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
         else
            nSubs = 0 ;
      }
     // altrimenti sottocurva di composita
      else {
         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
         pCurve = ( pCompo != nullptr ? pCompo->GetCurve( Id.nSub) : nullptr) ;
         if ( pCurve == nullptr)
            return false ;
         nSubs = 0 ;
      }
      return true ;
   }
  // se altrimenti ammessi testi ed è tale
   else if ( ( nType == GEO_NONE  ||  nType == EXT_TEXT)  &&  pGObj->GetType() == EXT_TEXT) {
      nType = EXT_TEXT ;
      const IExtText* pText = ::GetExtText( pGObj) ;
      if ( pText == nullptr)
         return false ;
      nSubs = 0 ;
      return true ;
   }
  // se altrimenti ammesse superfici trimesh ed è tale
   else if ( ( nType == GEO_NONE  ||  nType == SRF_TRIMESH)  &&  pGObj->GetType() == SRF_TRIMESH) {
      nType = SRF_TRIMESH ;
      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
      if ( pSurf == nullptr)
         return false ;
      // se direttamente la superficie
      if ( Id.nSub == SEL_SUB_ALL) {
        // deve avere una sola faccia
         if ( pSurf->GetFacetCount() != 1)
            return false ;
         nSubs = 1 ;
      }
      // altrimenti faccia di superficie trimesh
      else {
        // se faccia non esistente
         if ( Id.nSub >= pSurf->GetFacetCount())
            return false ;
         nSubs = 0 ;
      }
      return true ;
   }
  // se altrimenti ammesse regioni ed è tale
   else if ( ( nType == GEO_NONE  ||  nType == SRF_FLATRGN)  &&  pGObj->GetType() == SRF_FLATRGN) {
      nType = SRF_FLATRGN ;
      const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
      if ( pReg == nullptr)
         return false ;
      // se direttamente la regione
      if ( Id.nSub == SEL_SUB_ALL) {
         nSubs = pReg->GetChunkCount() ;
      }
      // altrimenti chunk di regione
      else {
        // se chunk non esistente
         if ( Id.nSub >= pReg->GetChunkCount())
            return false ;
        // tutto bene
         nSubs = 0 ;
      }
      return true ;
   }
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GetCurves( SelData Id, ICURVEPLIST& lstPC)
{
  // ammessi : curve, testi, facce di trimesh o regioni
   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()) ;
        // recupero eventuali informazioni per lati aperti
         SetCurveAllTempProp( Id.nId, false, pCurve) ;
        // 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()) ;
        // reset proprietà temporanee
         ResetCurveAllTempProp( pCurve) ;
        // 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 testo
   else if ( pGObj->GetType() == EXT_TEXT) {
     // recupero il testo
      const IExtText* pText = ::GetExtText( pGObj) ;
      if ( pText == nullptr)
         return false ;
     // recupero l'outline del testo
      if ( ! pText->GetOutline( lstPC))
         return false ;
     // reset proprietà temporanee
      for ( auto pCrv : lstPC)
         ResetCurveAllTempProp( pCrv) ;
     // porto le curve in globale
      for ( auto pCrv : lstPC)
         pCrv->ToGlob( frGlob) ;
     // ritorno
      return true ;
   }
  // se altrimenti superficie
   else if ( pGObj->GetType() == SRF_TRIMESH) {
     // recupero la trimesh 
      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
      if ( pSurf == nullptr)
         return false ;
     // recupero l'indice della faccia
      int nFacet = ( ( Id.nSub == SEL_SUB_ALL) ? 0 : Id.nSub) ;
     // recupero i contorni della faccia
      POLYLINEVECTOR vPL ;
      pSurf->GetFacetLoops( nFacet, vPL) ;
      if ( vPL.empty())
         return false ;
     // per ogni loop recupero le curve composite
      for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
         PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
         pCrvCompo->FromPolyLine( vPL[i]) ;
         if ( ! pCrvCompo->IsValid())
            return false ;
        // reset proprietà temporanee
         ResetCurveAllTempProp( pCrvCompo) ;
        // determino eventuali lati aperti e aggiorno proprietà del contorno
         int nInd = 0 ;
         double dPar ;
         bool bFound = vPL[i].GetFirstU( dPar, true) ;
         while ( bFound) {
           // recupero il flag
            int nFlag = int( dPar) ;
           // se non c'è nulla di adiacente, lato aperto 
            if ( nFlag == SVT_NULL)
               pCrvCompo->SetCurveTempProp( nInd, 1) ;
           // altrimenti verifico se la faccia adiacente forma diedro convesso o concavo
            else {
               bool bAdjac ;
               Point3d ptP1, ptP2 ;
               double dAng ;
               if ( ! pSurf->GetFacetsContact( nFacet, nFlag, bAdjac, ptP1, ptP2, dAng))
                  dAng = - ANG_RIGHT ;
               if ( dAng > - EPS_ANG_SMALL)
                  pCrvCompo->SetCurveTempProp( nInd, 1) ;
            }
           // passo al successivo
            ++ nInd ;
            bFound = vPL[i].GetNextU( dPar, true) ;
         }
        // recupero la normale esterna della faccia
         Vector3d vtN ;
         if ( ! pSurf->GetFacetNormal( nFacet, vtN))
            return false ;
        // assegno l'estrusione dalla normale alla faccia
         pCrvCompo->SetExtrusion( vtN) ;
        // unisco le eventuali parti allineate
         pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
        // la porto in globale
         pCrvCompo->ToGlob( frGlob) ;
        // sistemazioni varie
         AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
        // la restituisco
         lstPC.emplace_back( Release( pCrvCompo)) ;
      }
      return true ;
   }
  // se altrimenti regione
   else if ( pGObj->GetType() == SRF_FLATRGN) {
     // recupero la regione
      const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
      if ( pReg == nullptr)
         return false ;
     // recupero la normale della regione
      Vector3d vtN = pReg->GetNormVersor() ;
      if ( vtN.IsSmall())
         return false ;
     // determino intervallo di chunk
      int nCstart = 0 ;
      int nCend = pReg->GetChunkCount() ;
      if ( Id.nSub != SEL_SUB_ALL) {
         nCstart = Id.nSub ;
         nCend = nCstart + 1 ;
      }
     // ciclo sui chunk
      for ( int nC = nCstart ; nC < nCend ; ++ nC) {
        // recupero i contorni del chunk
         for ( int nL = 0 ; nL < pReg->GetLoopCount( nC) ; ++ nL) {
            PtrOwner<ICurveComposite> pCrvCompo ;
            if ( ! pCrvCompo.Set( ConvertCurveToComposite( pReg->GetLoop( nC, nL))))
               return false ;
           // reset proprietà temporanee
            ResetCurveAllTempProp( pCrvCompo) ;
           // assegno l'estrusione dalla normale alla regione
            pCrvCompo->SetExtrusion( vtN) ;
           // unisco le eventuali parti allineate
            pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
           // la porto in globale
            pCrvCompo->ToGlob( frGlob) ;
           // sistemazioni varie
            AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
           // la restituisco
            lstPC.emplace_back( Release( pCrvCompo)) ;
         }
      }
      return true ;
   }
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen)
{
   if ( pCurve == nullptr)
      return false ;
   if ( pbSomeOpen != nullptr)
      *pbSomeOpen = false ;
  // reset proprietà temporanee
   ResetCurveAllTempProp( pCurve) ;
  // se forzato chiuso o non presenti info per lati aperti, esco
   if ( bForcedClose  ||  ! m_pGeomDB->ExistsInfo( nCrvId, KEY_OPEN))
      return true ;
  // recupero info sui lati aperti
   INTVECTOR vOpen ;
   m_pGeomDB->GetInfo( nCrvId, KEY_OPEN, vOpen) ;
  // se curva composita
   ICurveComposite* pCC = GetCurveComposite( pCurve) ;
   if ( pCC != nullptr) {
      for ( int j : vOpen) {
         if ( pCC->SetCurveTempProp( j, 1)) {
            if ( pbSomeOpen != nullptr)
               *pbSomeOpen = true ;
         }
      }
   }
  // altrimenti
   else {
      if ( ! vOpen.empty()  &&  vOpen[0] == 0) {
         pCurve->SetTempProp( 1) ;
         if ( pbSomeOpen != nullptr)
            *pbSomeOpen = true ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::SetSfrLoopsAllTempProp( int nSfrId, ISurfFlatRegion* pSfr)
{
   if ( pSfr == nullptr)
      return false ;
   pSfr->SetTempProp( TEMP_PROP_INVALID, 0) ;
   pSfr->SetTempProp( TEMP_PROP_INVALID, 1) ;
  // recupero le info per lati aperti
   int nCount = -1 ;
   while ( m_pGeomDB->ExistsInfo( nSfrId, KEY_OPEN + ToString( ++ nCount))) {
     // recupero info sui lati aperti
      INTVECTOR vOpen ;
      m_pGeomDB->GetInfo( nSfrId, KEY_OPEN + ToString( nCount), vOpen) ;
     // se non ho lati aperti, passo al loop successivo
      if ( vOpen.empty())
         continue ;
     // assegno le properità di lato aperto
      for ( int i = 0 ; i < pSfr->GetLoopCurveCount( 0, nCount) ; ++ i) {
         pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_CLOSE_EDGE, 0) ;
         pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_INVALID, 1) ;
      }
      for ( int& i : vOpen)
         pSfr->SetCurveTempProp( 0, nCount, i, TEMP_PROP_OPEN_EDGE, 0) ;
   } ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ResetCurveAllTempProp( ICurve* pCurve)
{
   if ( pCurve == nullptr)
      return false ;
   pCurve->SetTempProp( 0) ;
   ICurveComposite* pCC = GetCurveComposite( pCurve) ;
   if ( pCC != nullptr) {
      for ( int i = 0 ; i < pCC->GetCurveCount() ; ++ i)
         pCC->SetCurveTempProp( i, 0) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::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 PocketingNT : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2451, sInfo) ;
      }
      for ( auto pCrv : lstPC) {
         vpCrvs.emplace_back( pCrv) ;
         vInds.emplace_back( Id) ;
      }
   }
  // preparo i dati per il concatenamento
   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) {
         ptNear = ptStart + 10 * EPS_SMALL * vtStart ;
         bFirst = 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 ;
     // se la curva non è chiusa, errore
      if (  ! pCrvCompo->IsClosed()) {
         m_pMchMgr->SetLastError( 2402, "Error in PocketingNT : Open Contour") ;
         return false ;
      }
     // 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 PocketingNT : Contour Not Flat") ;
         else
            m_pMchMgr->SetLastError( 2404, "Error in PocketingNT : 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, true))
         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()) {
     // 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) ;
            }
            if ( ! vIndOpen.empty())
               m_pGeomDB->SetInfo( nNewId, KEY_OPEN + ToString( nL), vIndOpen) ;
           // 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) ;
               Vector3d vtExtr ;
               pCrvLoop->GetExtrusion( vtExtr) ;
               m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
            }
         }
      }
     // aggiorno la regione piana con la successiva calcolata
      pSfrCurr.Set( SfrByC.GetSurf()) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetRaw( void)
{
  // controllo MachManager e database geometrico
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
      return nullptr ;

  // creo Stm del grezzo
   PtrOwner<ISurfTriMesh> pStmRaw( CreateSurfTriMesh()) ;
   if ( IsNull( pStmRaw))
      return nullptr ;
   pStmRaw->AdjustTopology() ;

  // Id prima RawPart
   int nRawId = m_pMchMgr->GetFirstRawPart() ;

   while ( nRawId != GDB_ID_NULL) {
     // verifico che il grezzo compaia nella fase
      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
        // recupero l'oggetto dal database con tale Id
         int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
         const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
         if ( pGObj == nullptr)
            return nullptr ;
        // recupero il frame in cui si trova
         Frame3d frRaw ;
         m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
        // controllo che sia una Trimesh
         if ( pGObj->GetType() == SRF_TRIMESH) {
            SurfLocal StmRawPart( GetSurfTriMesh( pGObj), frRaw, GLOB_FRM) ;
           // lo aggiungo alla Trimesh complessiva
            pStmRaw->Add( *GetSurfTriMesh( StmRawPart)) ;
         }
      }
     // passo al grezzo successivo
      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
   }

   return ( ( pStmRaw->IsValid()  &&  pStmRaw->GetTriangleCount() > 0) ? Release( pStmRaw) : nullptr) ;
}

//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtTrasl, const Vector3d& vtExtr)
{
  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return nullptr ;

  /*
      pSfr -> superficie da cui estrudere i lati chiusi
      vtTrals -> vettore di traslazione della superficie, per posizionarla all'ultimo Step
      vtExtrs -> vettore estrusione dei lati chiusi di pSfr
  */

   PtrOwner<ISurfFlatRegion> pMySfr( CloneSurfFlatRegion( pSfr)) ;
   if ( IsNull( pMySfr)  ||  ! pMySfr->IsValid())
      return nullptr ;
   pMySfr->Translate( vtTrasl) ;

  // zuppa di triangoli
   StmFromTriangleSoup stmSoup ;
   stmSoup.Start() ;

  // scorro i Loop della superficie piana
   bool bExistClose = false ;
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
        // recupero il Loop come curva composita
         PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCompoLoop)  ||  !  pCompoLoop->IsValid())
            return nullptr ;
        // recupero i tratti con proprietà uniformi
         ICRVCOMPOPOVECTOR vpCrvs ;
         int nCurrTempProp ;
         int nParStart = 0 ;
         for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
           // ricavo la TmpProp
            int nTempProp = TEMP_PROP_INVALID ;
            pCompoLoop->GetCurveTempProp( nU, nTempProp) ;
            if ( nU == 0) {
               nCurrTempProp = nTempProp ;
               nParStart = nU ;
            }
           // se TmpProp differiscono, ricavo il tratto di curva omogeneo
            else if ( nCurrTempProp != nTempProp) {
               PtrOwner<ICurveComposite> pCrv( ConvertCurveToComposite( pCompoLoop->CopyParamRange( nParStart, nU))) ;
               if ( IsNull( pCrv))
                  return nullptr ;
               pCrv->SetTempProp( nCurrTempProp) ; // globale, al tratto di curva nel vettore
               vpCrvs.emplace_back( Release( pCrv)) ;
               nCurrTempProp = nTempProp ;
               nParStart = nU ;
            }
         }
        // ultima curva...
         PtrOwner<ICurveComposite> pCrvLast( ConvertCurveToComposite( pCompoLoop->CopyParamRange( nParStart, pCompoLoop->GetCurveCount()))) ;
         if ( ! IsNull( pCrvLast)) {
            pCrvLast->SetTempProp( nCurrTempProp) ;
            vpCrvs.emplace_back( Release( pCrvLast)) ;
         }
         if ( vpCrvs.size() > 1) { // unisco il primo e l'ultimo se estremi compatibili
            Point3d ptE ; vpCrvs.back()->GetEndPoint( ptE) ;
            Point3d ptS ; vpCrvs[0]->GetStartPoint( ptS) ;
            if ( AreSamePointApprox( ptS, ptE)  &&  vpCrvs[0]->GetTempProp() == vpCrvs.back()->GetTempProp()) {
               vpCrvs[0]->AddCurve( Release( vpCrvs.back()), false) ;
               vpCrvs.erase( vpCrvs.end() - 1) ;
            }
         }
        // scorro i tratti omogenei chiusi
         for ( int nP = 0 ; nP < int( vpCrvs.size()) ; ++ nP) {
            if ( vpCrvs[nP]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
              // approssimo la curva ad una PolyLine
               PolyLine PL ;
               vpCrvs[nP]->ApproxWithLines( 10 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL) ;
              // estrusione del tratto chiuso
               PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
               if ( IsNull( pStm)  ||
                    ! pStm->AdjustTopology()  ||
                    ! pStm->CreateByExtrusion( PL, vtExtr))
                  return nullptr ;
              // aggiungo i triangoli ricavati alla zuppa
               if ( ! IsNull( pStm)  &&  pStm->IsValid()) {
                  for ( int nT = 0 ; nT < pStm->GetTriangleCount() ; ++ nT) {
                     Triangle3d myTria ; pStm->GetTriangle( nT, myTria) ;
                     stmSoup.AddTriangle( myTria) ;
                  }
                  bExistClose = true ;
               }
            }
         }
      }
   }

  // inizializzo la superficie di estrusione
   PtrOwner<ISurfTriMesh> pStmExtrusion( CreateSurfTriMesh()) ;
   if ( IsNull( pStmExtrusion))
      return nullptr ;
   pStmExtrusion->AdjustTopology() ;
   stmSoup.End() ;
   if ( bExistClose) {
      pStmExtrusion.Set( stmSoup.GetSurf()) ;
      if ( IsNull( pStmExtrusion))
         return nullptr ;
      return ( ( pStmExtrusion->IsValid()  &&  pStmExtrusion->GetTriangleCount() > 0) ? Release( pStmExtrusion) : nullptr) ;
   }
   return ( Release( pStmExtrusion)) ;
}

//----------------------------------------------------------------------------
ISurfFlatRegion*
PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs)
{
  // interseco la superficie alla quota corrente
   PNTVECTOR vPnt ; 
   BIPNTVECTOR vBpt ;
   TRIA3DVECTOR vTria ;
   if ( ! IPPStm.GetInters( dDist, vPnt, vBpt, vTria))
      return nullptr ;

  // se non c'è intersezione
   if ( vBpt.empty())
      return CreateSurfFlatRegion() ;

  // definisco la tolleranza per i concatenamenti
   double dToler = EPS_SMALL ;

  // costruisco la FlatRegion da ritornare
   SurfFlatRegionByContours SfrByC ;

  // Considero l'intersezione solo con Curve ( escludo punti e superfici)
   ChainCurves chainC ;
   chainC.Init( false, dToler, int( vBpt.size())) ;
   for ( int i = 0 ; i < int( vBpt.size()) ; ++ i) {
      Vector3d vtDir = vBpt[i].second - vBpt[i].first ;
      vtDir.Normalize() ;
      if ( ! chainC.AddCurve( i + 1, vBpt[i].first, vtDir, vBpt[i].second, vtDir))
         return nullptr ;
   }
  // recupero i percorsi concatenati
   Point3d ptNear = ( vBpt.empty() ? ORIG : vBpt[0].first) ;
   INTVECTOR vId ;
   while ( chainC.GetChainFromNear( ptNear, false, vId)) {
     // creo una curva composita
      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
      if ( IsNull( pCrvCompo))
         return nullptr ;
     // recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita
      bool bAdded = true ;
      for ( int i = 0 ; i < int( vId.size()) ; ++ i) {
        // creo un segmento di retta
         PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
         if ( IsNull( pLine))
            return nullptr ;
        // recupero gli estremi ( non vanno mai invertiti per opzione di concatenamento)
         int nInd = abs( vId[i]) - 1 ;
         Point3d ptStart = ( bAdded ? vBpt[nInd].first : ptNear) ;
         Point3d ptEnd = vBpt[nInd].second ;
        // provo ad accodarlo alla composita
         bAdded = ( Dist( ptStart, ptEnd) > dToler / 2  &&
            pLine->Set( ptStart, ptEnd)  &&
            pCrvCompo->AddCurve( Release( pLine), true, dToler)) ;
         ptNear = ( bAdded ? ptEnd : ptStart) ;
      }
     // se lunghezza curva inferiore a 5 volte la tolleranza, la ignoro
      double dCrvLen ;
      if ( ! pCrvCompo->GetLength( dCrvLen)  ||  dCrvLen < 5. * dToler)
         continue ;
     // se curva chiusa entro 5 volte la tolleranza ma considerata aperta, la chiudo bene
      Point3d ptStart, ptEnd ;
      if ( pCrvCompo->GetStartPoint( ptStart)  &&
         pCrvCompo->GetEndPoint( ptEnd)  &&
         AreSamePointEpsilon( ptStart, ptEnd, 5. * dToler)  &&
         ! AreSamePointApprox( ptStart, ptEnd)) {
        // porto il punto finale a coincidere esattamente con l'inizio
         pCrvCompo->ModifyEnd( ptStart) ;
      }
     // unisco segmenti allineati
      pCrvCompo->MergeCurves( 0.5 * dToler, ANG_TOL_STD_DEG) ;
      pCrvCompo->Close() ; // per sicurezza...
     // inserisco la curva nella FlatRegion
      SfrByC.AddCurve( Release( pCrvCompo)) ;
   }

  // recupero la regione da restituire
   PtrOwner<ISurfFlatRegion> pSfrFromCrvs( SfrByC.GetSurf()) ;
   return ( ( ! IsNull( pSfrFromCrvs)  &&  pSfrFromCrvs->IsValid()) ? Release( pSfrFromCrvs) : nullptr) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion)
{

  // controllo parametri :
   if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||
        pStmExtrusion == nullptr)
      return false ;

  // se non ho una superificie di estrusione, allora è tutto aperto
   if ( ! pStmExtrusion->IsValid()  ||  pStmExtrusion->GetTriangleCount() == 0) {
      for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC)
         for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL)
            for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) ; ++ nU)
               pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ;
      return true ;
   }

  // per ogni curva dei Loop della FlatRegion vengono presi 4 punti di controllo equidistanti.
  // " IL LATO E' APERTO <=> TUTTI I PUNTI DI CONTROLLO NON SONO A CONTATTO CON pStmExtrusion "
   const int NUM_POINTS = 4 ;
  // scorro tutti i loop
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
        // recupero la curva composita del Loop
         PtrOwner<ICurveComposite> pCrvCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCrvCompoLoop)  ||  ! pCrvCompoLoop->IsValid())
            return false ;
        // scorro ogni sua sottocurva
         for ( int nU = 0 ; nU < pCrvCompoLoop->GetCurveCount() ; ++ nU) {
           // la sottocurva viene messa chiusa ( condizione base)
            pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_OPEN_EDGE, 0) ;
           // recupero la sottocurva
            const ICurve* pCrv = pCrvCompoLoop->GetCurve( nU) ;
            if ( pCrv == nullptr)
               return false ;
           // recupero i NUM_POINTS punti
            bool bIsOnStm = true ;
            for ( int p = 0 ; p < NUM_POINTS + 1  &&  bIsOnStm ; ++ p) {
               double dPar = ( 1. / ( 1. * NUM_POINTS)) * p ;
               Point3d ptPar ;
               if ( ! pCrv->GetPointD1D2( dPar, ICurve::FROM_PLUS, ptPar))
                  return false ;
              // scorro il vettore relativo alla regione di riferimento
               DistPointSurfTm distCalculator( ptPar, *pStmExtrusion) ;
               double dDist = 0. ;
               distCalculator.GetDist( dDist) ;
               bIsOnStm = ( dDist < 25 * EPS_SMALL) ;
            }
            if ( bIsOnStm)
               pSfr->SetCurveTempProp( nC, nL, nU, TEMP_PROP_CLOSE_EDGE, 0) ;
         }
      }
   }

  return true ;

}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrRaw, ISurfFlatRegion* pSfrLimit)
{
  // controllo dei parametri
   if ( pSfrPock == nullptr  ||  ! pSfrPock->IsValid()  ||
        pSfrRaw == nullptr  ||  ! pSfrRaw->IsValid())
      return false ;
   pSfrLimit->Clear() ;

  // la superficie limite è data dalla sottrazione tra il grezzo e la superficie da svuotare
   pSfrLimit->CopyFrom( pSfrRaw) ;
   if ( pSfrLimit == nullptr  ||  ! pSfrLimit->IsValid())
      return false ;
  // piccolo Offset di correzione
   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfrPock->CreateOffsetSurf( 5 * EPS_SMALL, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrOffs)  ||  ! pSfrOffs->IsValid())
      return false ;
  // sottrazione
   pSfrLimit->Subtract( *pSfrOffs) ;

  // se richiesto non controllo dei lati aperti
   if ( m_bOpenOutRaw  &&  pSfrLimit->IsValid()) {
      for ( int nC = 0 ; nC < pSfrPock->GetChunkCount() ; ++ nC) {
         for ( int nL = 0 ; nL < pSfrPock->GetLoopCount( nC) ; ++ nL) {
           // recupero la curva di bordo
            PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfrPock->GetLoop( nC, nL)))  ;
            if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
               return false ;
           // recupero i tratti con proprietà omogenee
            ICRVCOMPOPOVECTOR vpCrvs ;
            int nCurrTempProp = TEMP_PROP_INVALID ;
            int nParStart = 0 ;
            for ( int i = 0 ; i < pCrvLoop->GetCurveCount() ; ++ i) {
              // ricavo la TmpProp
               int nTempProp = TEMP_PROP_INVALID ;
               pCrvLoop->GetCurveTempProp( i, nTempProp) ;
               if ( i == 0) {
                  nCurrTempProp = nTempProp ;
                  nParStart = i ;
               }
              // se TmpProp differiscono, ricavo il tratto di curva omogeneo
               else if ( nCurrTempProp != nTempProp) {
                  PtrOwner<ICurveComposite> pCrv( ConvertCurveToComposite( pCrvLoop->CopyParamRange( nParStart, i))) ;
                  if ( IsNull( pCrv))
                     return false ;
                  pCrv->SetTempProp( nCurrTempProp) ; // globale, al tratto di curva nel vettore
                  vpCrvs.emplace_back( Release( pCrv)) ;
                  nCurrTempProp = nTempProp ;
                  nParStart = i ;
               }
            }
           // ultima curva...
            PtrOwner<ICurveComposite> pCrvLast( ConvertCurveToComposite( pCrvLoop->CopyParamRange( nParStart, pCrvLoop->GetCurveCount()))) ;
            if ( ! IsNull( pCrvLast)) {
               pCrvLast->SetTempProp( nCurrTempProp) ;
               vpCrvs.emplace_back( Release( pCrvLast)) ;
            }
            if ( vpCrvs.size() > 1) { // unisco il primo e l'ultimo se estremi compatibili
               Point3d ptE ; vpCrvs.back()->GetEndPoint( ptE) ;
               Point3d ptS ; vpCrvs[0]->GetStartPoint( ptS) ;
               if ( AreSamePointApprox( ptS, ptE)  &&  vpCrvs[0]->GetTempProp() == vpCrvs.back()->GetTempProp()) {
                  vpCrvs[0]->AddCurve( Release( vpCrvs.back()), false) ;
                  vpCrvs.erase( vpCrvs.end() - 1) ;
               }
            }
           // scorro i tratti omogenei aperti
            for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
               if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
                 // regione da sottrarre
                  PtrOwner<ISurfFlatRegion> pSfrSubtract( CreateSurfFlatRegion()) ;
                  if ( IsNull( pSfrSubtract))
                     return false ;
                  if ( vpCrvs[i]->IsClosed()) {
                     pSfrSubtract.Set( GetSurfFlatRegionFromFatCurve( vpCrvs[i]->Clone(), 4 * m_TParams.m_dDiam + EPS_SMALL, false, false)) ;
                     if ( IsNull( pSfrSubtract)  ||  ! pSfrSubtract->IsValid())
                        return false ;
                  }
                  else {
                    // creo la curva di Offset esterna ( deve esistere ed essere valida)
                     OffsetCurve OffsCrv ;
                     PtrOwner<ICurve> pOffsExt( CreateCurveComposite()) ;
                     if ( IsNull( pOffsExt)  ||
                       ! OffsCrv.Make( vpCrvs[i], 4 * m_TParams.m_dDiam, ICurve::OFF_FILLET)  ||
                       ! pOffsExt.Set( OffsCrv.GetLongerCurve())  ||
                       IsNull( pOffsExt))
                     return false ;
                    // creo la curva di Offset interna ( se esiste e valida...)
                     PtrOwner<ICurve> pOffsInt( CreateCurveComposite()) ;
                     if ( IsNull( pOffsInt))
                        return false ;
                     if ( OffsCrv.Make( vpCrvs[i], - 4 * m_TParams.m_dDiam, ICurve::OFF_FILLET)) {
                        PtrOwner<ICurve> pMyCrv( OffsCrv.GetLongerCurve()) ;
                        if ( ! IsNull( pMyCrv)  &&  pMyCrv->IsValid())
                           pOffsInt.Set( pMyCrv) ;
                     }
                    // recupero gli estremi della curva aperta corrente
                     Point3d pt1 ; vpCrvs[i]->GetEndPoint( pt1) ;
                     Point3d pt4 ; vpCrvs[i]->GetStartPoint( pt4) ;
                    // verifico se una delle due curve esiste
                     bool bExistExt = ( ! IsNull( pOffsExt)  &&  pOffsExt->IsValid()) ;
                     bool bExistInt = ( ! IsNull( pOffsInt)  &&  pOffsInt->IsValid()) ;
                     PtrOwner<ICurveComposite> pCrvExtLoopSurfInc( CreateCurveComposite()) ;
                     if ( IsNull( pCrvExtLoopSurfInc))
                        return false ;
                     if ( bExistExt  &&  bExistInt) {
                        Point3d pt2 ; pOffsInt->GetEndPoint( pt2) ;
                        Point3d pt3 ; pOffsInt->GetStartPoint( pt3) ;
                        Point3d pt5 ; pOffsExt->GetStartPoint( pt5) ;
                        if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsExt))  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt1)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt2)  ||
                             ! pOffsInt->Invert()  ||
                             ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsInt))  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt4)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt5))
                           return false ;
                     }
                     else if ( bExistExt) {
                        Point3d pt5 ; pOffsExt->GetStartPoint( pt5) ;
                        if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsExt))  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt1)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt4)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt5))
                           return false ;
                     }
                     else if ( bExistInt) {
                        Point3d pt5 ; pOffsInt->GetStartPoint( pt5) ;
                        if ( ! pCrvExtLoopSurfInc->AddCurve( Release( pOffsInt))  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt1)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt4)  ||
                             ! pCrvExtLoopSurfInc->AddLine( pt5))
                           return false ;
                     }
                     else
                        return false ;
                    // per sicurezza...
                     pCrvExtLoopSurfInc->Close() ;
                     if ( ! pSfrSubtract->AddExtLoop( Release( pCrvExtLoopSurfInc)))
                        return false ;
                     if ( pSfrSubtract->IsValid()  &&  pSfrSubtract->GetChunkCount() > 0) {
                        Vector3d vtN = pSfrSubtract->GetNormVersor() ;
                        if ( AreOppositeVectorApprox( vtN, pSfrPock->GetNormVersor()))
                           pSfrSubtract->Invert() ;
                     }
                  }
                  if ( pSfrSubtract->IsValid())
                     pSfrLimit->Subtract( *pSfrSubtract) ;
               }
            }
         }
      }
   }

   return true ;

}

//----------------------------------------------------------------------------
bool
PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
{
  // aggiorno la ProgressBar del 5% per simulare l'inizio della funzione
   ExeProcessEvents( 5, 0) ;

  // 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 ;
   PtrOwner<ISurfFlatRegion> pSfr( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
   if ( IsNull( pSfr)  ||  ! pSfr->IsValid())
      return false ;

  // assegno le proprietà di lato aperto ai sui loops
   SetSfrLoopsAllTempProp( nSfrId, pSfr) ;

  // 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) ;

  // eventuale inversione direzione utensile
   if ( m_Params.m_bToolInvert) {
      pSfr->Invert() ;
      vtExtr.Invert() ;
      dThick = - 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( 2405, "Error in PocketingNT : Empty RawBox") ;
      return false ;
   }

  // recupero distanza da fondo dei grezzi interessati dal percorso
   double dRbDist = 0 ;
   if ( AreSameVectorApprox( vtExtr, Z_AX)) {
      if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, m_TParams.m_dTDiam, dRbDist))
         return false ;
   }

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

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

  // assegno il versore fresa
   Vector3d vtTool = vtExtr ;

  // recupero il Loop esterno della regione da svuotatare
   PtrOwner<ICurveComposite> pCrvLoopExt( ConvertCurveToComposite( pSfr->GetLoop( 0, 0))) ;
   if ( IsNull( pCrvLoopExt)  ||  ! pCrvLoopExt->IsValid())
      return false ;

  // calcolo l'elevazione massima
   double dElev ;
   if ( CalcRegionElevation( pCrvLoopExt, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, m_TParams.m_dLen, dElev)) {
      if ( dElev < EPS_SMALL  &&  AreSameVectorApprox( vtExtr, Z_AX)) {
         BBox3d b3Crv ;
         pCrvLoopExt->GetLocalBBox( b3Crv) ;
         dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z + min( 0., dThick) + dDepth) ;
      }
   }
   else
      return false ;
  // eventuale imposizione massima elevazione da note utente
   double dMaxElev ;
   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev)
      dElev = dMaxElev ;

  // verifico che lo step dell'utensile sia sensato
   double dOkStep = ( m_Params.m_dStep > EPS_SMALL ? m_Params.m_dStep + EPS_SMALL : 0) ;
   const double MIN_ZSTEP = 1.0 ;
   if ( dOkStep >= EPS_SMALL  &&  dOkStep < MIN_ZSTEP) {
      dOkStep = MIN_ZSTEP + EPS_SMALL ;
      string sInfo = "Warning in PocketingNT : machining step too small (" +
                     ToString( m_Params.m_dStep, 2) + ")" ;
      m_pMchMgr->SetWarning( 2456, sInfo) ;
   }

  // verifico che il massimo materiale dell'utensile sia sensato
   const double MIN_MAXMAT = 1.0 ;
   if ( m_TParams.m_dMaxMat < dElev  &&  m_TParams.m_dMaxMat < MIN_MAXMAT) {
      string sInfo = "Error in PocketingNT : Tool MaxMaterial too small (" +
                     ToString( m_TParams.m_dMaxMat, 2) + ")" ;
      m_pMchMgr->SetLastError( 2422, sInfo) ;
      return false ;
   }

  // verifico di non superare il massimo materiale
   // se lo step supera la capacità dell'utensile
   if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
      dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ;
      string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) +
                     ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
      m_pMchMgr->SetWarning( 2457, sInfo) ;
   }
  // se lavorazione singola
   if ( dOkStep < EPS_SMALL  ||  dOkStep > dElev) {
     // se l'elevazione supera la capacità dell'utensile
      if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
         string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) +
                        ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
         m_pMchMgr->SetWarning( 2458, sInfo) ;
         dDepth -= dElev - m_TParams.m_dMaxMat ;
         dElev = m_TParams.m_dMaxMat ;
      }
   }
  // altrimenti lavorazione a step
   else {
     // se l'elevazione supera il massimo affondamento dell'utensile
      double dSafe = GetMaxDepthSafe() ;
      double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
      if ( dElev > dMaxDepth + EPS_SMALL) {
        // segnalo, riduco e continuo
         string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) +
                        ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
         m_pMchMgr->SetWarning( 2458, sInfo) ;
         dDepth -= dElev - dMaxDepth ;
         dElev = dMaxDepth ;
      }
   }

  // verifico se tavola basculante
   bool bTiltTab = false ;
   m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx)  &&  bTiltTab) ;

  // verifico se testa da sopra (Z+)
   m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ;

  // verifiche per svuotature dal basso
   m_bAggrBottom = false ; 
   if ( ! VerifyPathFromBottom( pCrvLoopExt, vtTool))
      return false ;

  // recupero eventuale flag di lato aperto forzato fuori dal grezzo
   int nOpenOutRaw ;
   m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, "OpenOutRaw", nOpenOutRaw)  &&  nOpenOutRaw != 0) ;

  // recupero eventuale minima lunghezza di attacco su lato aperto
   m_dOpenMinSafe = 0 ;
   GetValInNotes( m_Params.m_sUserNotes, "OpenMinSafe", m_dOpenMinSafe) ;

  // se richiesta anteprima
   if ( nPvId != GDB_ID_NULL) {
     // creo gruppo per geometria di lavorazione del percorso
      int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ;
      if ( nPxId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nPxId, sPathName) ;
      m_pGeomDB->SetMaterial( nPxId, GREEN) ;
     // creo l'anteprima del percorso
      int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, CloneSurfFlatRegion( pSfr)) ;
      if ( nRId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
      m_pGeomDB->SetMaterial( nRId, Color( 255, 0, 0, 60)) ;
     // la copio anche come regione ridotta
      int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
      if ( nRrId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
      m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
   }

  // 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( vtExtr) ;

     // assegno il vettore estrazione al gruppo del percorso
      m_pGeomDB->SetInfo( nPxId, KEY_EXTR, vtTool) ;
     // assegno l'elevazione massima
      m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;

     // recupero il grezzo
      PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
      if ( IsNull( pStmRaw)) {
         m_pMchMgr->SetLastError( 3025, "Error in PocketingNT : RawPart not computable") ;
         return false ;
      }
      pStmRaw->Translate( - vtTool * 510 * EPS_SMALL) ; // per tasche passanti

     // determino numero e affondamento degli step
      int nStep = 1 ;
      nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
      double dStep = dElev / nStep ;

     // su tutti gli step ricavati, calcolo le PolyLine delle Silhouette
      int nPocket = 0 ; // numero effettivo di Pocketing calcolate
      int nProgressBarStep = 0 ; // step per progressBar

     // vettore per gli step
      STEPINFOPOVECTOR vStepInfo ;

     // inizializzo la classe di intersezione tra grezzo e piani paralleli ( quelli di lavoro)
      Frame3d frSfr ;
      Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
      Frame3d frPocket ;
      if ( ! frPocket.Set( ptCen, vtTool)  ||  ! frPocket.IsValid())
         return false ;
      IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ;

     // definisco una trimesh derivante dalla regione piana mediante estrusione dei lati chiusi
      Vector3d vtSfrTrasl = - vtTool * ( dDepth - dElev + nStep * dStep) ;
      Vector3d vtStmExtr = - vtTool * ( dDepth - dElev + dStep - 500 * EPS_SMALL) ;
      PtrOwner<ISurfTriMesh> pStmExtrusion( GetExtrusionStm( pSfr, vtSfrTrasl, vtStmExtr)) ;
      if ( IsNull( pStmExtrusion))
         return false ;

      if ( _m_Debug) {
         int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmExtrusion->Clone()) ;
         m_pGeomDB->SetMaterial( _a, Color( 1., 0., 1., .75)) ;
      }

      for ( int j = 1 ; j <= nStep ; ++ j) {
        // per i contatori non controllo se effettivamente svuoto una superficie o meno
         ++ nProgressBarStep ; // aggiorno step per progressBar

        // porto la superficie allo step corrente
         PtrOwner<ISurfFlatRegion> pSfrPock( CloneSurfFlatRegion( pSfr)) ;
         if ( IsNull( pSfrPock)  ||  ! pSfrPock->IsValid()  ||
              ! pSfrPock->Translate( - vtTool * ( dDepth - dElev + j * dStep)))
            return false ;

        // adatto la regione piana alla geometria del grezzo
         PtrOwner<ISurfFlatRegion> pSfrRaw( GetSfrByStmIntersection( IPPStm, - ( dDepth - dElev + j * dStep), 0)) ;
         if ( IsNull( pSfrRaw)) {
            m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
            return false ;
         }
         if ( pSfrRaw->IsValid()  &&  pSfrRaw->GetChunkCount() > 0)
            pSfrPock->Intersect( *pSfrRaw) ;

        // se regione risultante non vuota
         if ( pSfrPock->IsValid()  &&  pSfrPock->GetChunkCount() > 0) {
           // determino i lati aperti
            if ( ! ChooseCloseOrOpenEdge( pSfrPock, pStmExtrusion)) {
               m_pMchMgr->SetLastError( 3026, "Error in PocketingNT : Detecting open edges failed") ;
               return false ;
            }
            if ( _m_Debug)
               _debug_draw_sfr( pSfrPock, false) ;
           // determino la regione limite
            PtrOwner<ISurfFlatRegion> pSfrLimit( CreateSurfFlatRegion()) ;
            if ( IsNull( pSfrLimit)  ||
                 ! CalcLimitRegion( pSfrPock, pSfrRaw, pSfrLimit)) {
               m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Calc limit region failed") ;
               return false ;
            }

            if ( _m_Debug) {
               int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfrLimit->Clone()) ;
               m_pGeomDB->SetMaterial( _a, Color( .5, .5, .5, .5)) ;
            }
           // inserisco le informazioni dello step nel vettore
            vStepInfo.resize( vStepInfo.size() + 1) ;
            vStepInfo.back().dDepth = - j * dStep ;
            vStepInfo.back().dRelativeDepth = - dStep ;
            vStepInfo.back().pSfrPock.Set( Release( pSfrPock)) ;
            vStepInfo.back().pSfrLimit.Set( CreateSurfFlatRegion()) ;
            if ( pSfrLimit->IsValid())
               vStepInfo.back().pSfrLimit.Set( pSfrLimit) ;
         }

         ++ nPocket ;
        // aggiorno la progressBar
         ExeProcessEvents( 5 + nProgressBarStep * 45 / nStep, 0) ;

      }

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

      if ( ! AddPocket( vStepInfo, vtTool, dElev, dStep, bSplitArcs))
         return false ;
   }

  // incremento numero di svuotature
   ++ m_nPockets ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dLen,
                                double& dElev)
{
  // inizializzo l'elevazione
   dElev = 0 ;

  // approssimo la curva con una polilinea che uso per creare il poligono equivalente
   PolyLine PL ;
   if ( ! pCompo->ApproxWithLines( LIN_TOL_RAW, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
      return false ;
   Polygon3d pgFacet ;
   if ( ! pgFacet.FromPolyLine( PL))
      return false ;
  // aggiungo l'affondamento
   pgFacet.Translate( -dDepth * vtTool) ;

  // inizializzo elevazioni per ogni grezzo
   INTDBLVECTOR vRawElev ;
  // ciclo sui grezzi della fase
   int nRawId = m_pMchMgr->GetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
     // verifico che il grezzo compaia nella fase
      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
        // recupero la trimesh del grezzo
         int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
         const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
         if ( pStm != nullptr) {
           // recupero il riferimento della trimesh
            Frame3d frStm ;
            m_pGeomDB->GetGlobFrame( nStmId, frStm) ;
           // porto il poligono in questo riferimento
            Polygon3d pgFacetL = pgFacet ;
            pgFacetL.ToLoc( frStm) ;
           // calcolo l'elevazione
            double dCurrElev ;
            if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev))
               return false ;
            if ( dCurrElev > EPS_SMALL)
               vRawElev.emplace_back( nStmId, dCurrElev) ;
         }
      }
     // passo al grezzo successivo
      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
   }
  // se trovate elevazioni
   if ( ! vRawElev.empty()) {
     // ordino il vettore secondo l'elevazione crescente
      sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b)
                                                  { return a.second < b.second ; }) ;
     // box dell'insieme delle posizioni utensile all'inizioe
      const double MAX_DIST_RAW = 200.0 ;
      BBox3d b3Tool ;
      pgFacet.GetLocalBBox( b3Tool) ;
      b3Tool.Add( b3Tool.GetMin() + dLen * vtTool) ;
      b3Tool.Add( b3Tool.GetMax() + dLen * vtTool) ;
      if ( vtTool.IsX())
         b3Tool.Expand( 0, dRad, dRad) ;
      else if ( vtTool.IsY())
         b3Tool.Expand( dRad, 0, dRad) ;
      else if ( vtTool.IsZ())
         b3Tool.Expand( dRad, dRad, 0) ;
      else {
         double dExpandX = dRad * sqrt( 1 - vtTool.x * vtTool.x) ;
         double dExpandY = dRad * sqrt( 1 - vtTool.y * vtTool.y) ;
         double dExpandZ = dRad * sqrt( 1 - vtTool.z * vtTool.z) ;
         b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
      }
      b3Tool.Expand( MAX_DIST_RAW) ;
     // verifico la reale interferenza dell'utensile con i diversi grezzi
      for ( int i = 0 ; i < int( vRawElev.size()) ; ++ i) {
        // box del grezzo
         BBox3d b3Raw ; 
         m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
        // confronto con il box dell'utensile nella posizione precedente
         BBox3d b3CurrTool = b3Tool ;
         b3CurrTool.Translate( dElev * vtTool) ;
         if ( b3Raw.Overlaps( b3CurrTool))
            dElev = vRawElev[i].second ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
{
  // se non è svuotatura dal basso in alto, esco
   if ( vtTool.z > MIN_ZDIR_TOP_TOOL)
      return true ;
  // se c'è testa non dall'alto o tavola basculante, esco
   if ( ! m_bAboveHead  ||  m_bTiltingTab)
      return true ;
  // recupero dati di eventuale rinvio da sotto
   if ( ! GetAggrBottomData( m_TParams.m_sHead, m_AggrBottom)  ||  m_AggrBottom.nType == 0) {
      m_pMchMgr->SetLastError( 2409, "Error in PocketingNT : missing aggregate from bottom") ;
      return false ;
   }

  // calcolo il minimo della massima distanza del percorso dal contorno del grezzo
   double dMinDist = INFINITO ;
   Vector3d vtMinDir ;
   VCT3DVECTOR vDir ;
   double dParS, dParE ; pCompo->GetDomain( dParS, dParE) ;
   for ( double dPar = dParS ; dPar < dParE + EPS_PARAM ; dPar += 0.5) {
     // distanza minima del punto e relativa direzione dal contorno del grezzo
      Point3d ptP ; double dCurrDist = INFINITO ; Vector3d vtCurrDir ;
      if ( pCompo->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptP)  &&
           GetMinDistanceFromRawSide( m_nPhase, ptP, 0, m_AggrBottom.vtMDir, MCH_AGB_DELTAMAX_MDIR, dCurrDist, vtCurrDir)  &&
           ! vtCurrDir.IsSmallXY()) {
         if ( dCurrDist < dMinDist - 10 * EPS_SMALL  &&
              find_if( vDir.begin(), vDir.end(), [&](const Vector3d& vtV){ return vtCurrDir * vtV > cos( 15 * DEGTORAD) ; }) == vDir.end()) {
           // inserisco la direzione tra quelle già esplorate
            vDir.emplace_back( vtCurrDir) ;
           // determino la distanza di tutti gli altri punti dal contorno del grezzo lungo questa direzione
            for ( double dPar2 = dParS ; dPar2 < dParE + EPS_PARAM ; dPar2 += 0.5) {
               if ( abs( dPar2 - dPar) > EPS_PARAM) {
                  Point3d ptQ ;
                  double dQDist ;
                  if ( pCompo->GetPointD1D2( dPar2, ICurve::FROM_MINUS, ptQ)  &&
                       GetDistanceFromRawSide( m_nPhase, ptQ, vtCurrDir, dQDist)  &&  dQDist > dCurrDist)
                     dCurrDist = dQDist ;     
               }
            }
           // se la massima distanza trovata è inferiore al minimo, lo aggiorno
            if ( dCurrDist < dMinDist) {
               dMinDist = dCurrDist ;
               vtMinDir = vtCurrDir ;
            }
         }
      }
   }

  // se supera il limite, errore
   if ( dMinDist - ( m_TParams.m_dDiam / 2 + GetOffsR()) > m_AggrBottom.dDMax) {
      m_pMchMgr->SetLastError( 2410, "Error in PocketingNT : path too far from part sides") ;
      return false ;
   }

  // assegno direzione di accesso e segnalo utilizzo aggregato da sotto
   m_vtAggrBottom = vtMinDir ;
   m_bAggrBottom = true ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo)
{
  // creo copia della curva composita
   PtrOwner<ICurve> pCrv( pCompo->Clone()) ;
   if ( IsNull( pCrv))
      return false ;
  // calcolo la regione
   SurfFlatRegionByContours SfrCntrRr ;
   SfrCntrRr.AddCurve( Release( pCrv)) ;
   PtrOwner<ISurfFlatRegion> pSfr( SfrCntrRr.GetSurf()) ;
   if ( IsNull( pSfr))
      return false ;
  // ne recupero il contorno
   PtrOwner< ICurve> pCrv2 ;
   pCrv2.Set( pSfr->GetLoop( 0, 0)) ;
   if ( IsNull( pCrv2))
      return false ;
   // inserisco la curva nel DB
   int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
   if ( nC2Id == GDB_ID_NULL)
      return false ;
   // assegno nome e colore
   m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ;
   m_pGeomDB->SetMaterial( nC2Id, RED) ;
  // eventuali altri contorni ( interni di contornatura chiusa)
   const int MAX_INT_LOOP = 1000 ;
   for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) {
      PtrOwner< ICurve> pCrv3 ;
      pCrv3.Set( pSfr->GetLoop( 0, i)) ;
      if ( IsNull( pCrv3))
         break ;
     // inserisco la curva nel DB
      int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ;
      if ( nC3Id == GDB_ID_NULL)
         return false ;
     // assegno nome e colore
      m_pGeomDB->SetName( nC3Id, MCH_PV_CUT) ;
      m_pGeomDB->SetMaterial( nC3Id, RED) ;
   }
  // inserisco la regione nel DB
   int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
   if ( nRId == GDB_ID_NULL)
      return false ;
   m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
   m_pGeomDB->SetMaterial( nRId, Color( 255, 0, 0, 60)) ;
  // la copio anche come regione ridotta
   int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
   if ( nRrId == GDB_ID_NULL)
      return false ;
   m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
   m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo)
{
  /*
      funzione per calcolo dei percorsi di Pockets e delle loro proprietà
  */

  // punto finale di riferimento per il percorso attuale ( serve per trovare il punto iniziale
  // del percorso successivo)
   Point3d ptEndLastPath = P_INVALID ;

  // scorro gli indici delle superfici
   for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) {
     // calcolo i percorsi di Pocketing
      ICRVCOMPOPOVECTOR vCrvPaths ;
      if ( ! CalcPocketing( vStepInfo[i].pSfrPock, m_TParams.m_dDiam / 2, 0., m_Params.m_dSideStep,
                            m_Params.m_dSideAngle, m_Params.m_nSubType, true, m_Params.m_bInvert,
                            false, true, ptEndLastPath, vStepInfo[i].pSfrLimit, false, vCrvPaths)) {
            m_pMchMgr->SetLastError( 3028, "Error in PocketingNT : Error in CalcPocketing") ;
            return false ;
         }
     // se non ho ottenuto percorsi, allora passo allo step successivo ( nInd non viene aggiornato!)
      if ( vCrvPaths.empty())
         continue ;
     // sistemo gli archi per massimo angolo al centro
      for ( int i = 0 ; i < int( vCrvPaths.size()) ; ++ i)
         VerifyArcs( vCrvPaths[i]) ;
     // recupero il punto finale del percorso per lo step successivo
      vCrvPaths.back()->GetEndPoint( ptEndLastPath) ;
     // inserisco i percorsi nel vettore dei Paths
      vStepInfo[i].vPaths.resize( int( vCrvPaths.size())) ;
      for ( int j = 0 ; j < int( vCrvPaths.size()) ; ++ j) {
         // controllo se il percorso ha un ingresso presso un lato aperto
          vStepInfo[i].vPaths[j].bOutStart = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                               vCrvPaths[j]->GetFirstCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;

        // controllo se il percorso è formato da una singola curva seguente il lato chiuso
         vStepInfo[i].vPaths[j].bSingleCrv = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                               vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_SINGLE_CURVE) ;

        // controllo se caso ottimizzato a trapezio
         vStepInfo[i].vPaths[j].bOptTrap = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                             vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_OPT_TRAPEZOID) ;

        // controllo se è un percorso a ZigZag/OneWay ( non curva di bordo)
         vStepInfo[i].vPaths[j].bIsZigZagOneWayBorder = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                                        ( m_Params.m_nSubType == POCKET_SUB_ONEWAY  ||  m_Params.m_nSubType == POCKET_SUB_ZIGZAG)  &&
                                                          vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_BORDER_CURVE) ;

        // se LeadIn o LeadOut a guida recupero la curva di ritorno se necessaria
         if ( ( GetLeadInType() == POCKET_LI_GLIDE  ||  GetLeadOutType() == POCKET_LO_GLIDE)  &&
              ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN  &&
              ! vStepInfo[i].vPaths[j].bSingleCrv  &&  ! vStepInfo[i].vPaths[j].bOutStart))
         {
            if ( vStepInfo[i].vPaths[j].bOptTrap)
               vStepInfo[i].vPaths[j].pCrvRet.Set( ConvertCurveToComposite( vCrvPaths[i]->GetFirstCurve()->Clone())) ;
            else {
               Point3d ptStart ; vCrvPaths[j]->GetFirstCurve()->GetStartPoint( ptStart) ;
               vStepInfo[i].vPaths[j].pCrvRet.Set( CreateCurveComposite()) ;
               for ( int k = 0 ; k < vCrvPaths[j]->GetCurveCount() ; ++ k) {
                  const ICurve* pCrv = vCrvPaths[j]->GetCurve( k) ;
                  Point3d ptEnd ;
                  if ( pCrv == nullptr  ||
                       ! vStepInfo[i].vPaths[j].pCrvRet->AddCurve( *pCrv)  ||
                       ! pCrv->GetEndPoint( ptEnd))
                     return false ;
                  if ( AreSamePointApprox( ptStart, ptEnd))
                     break ;
               }
            }
         }

        // assegno il percorso
         vStepInfo[i].vPaths[j].pCrvPath.Set( vCrvPaths[j]) ;
      }
     // aggiorno la progressBar
      ExeProcessEvents( 50 + i * 50 / int( vStepInfo.size()), 0) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dElev, double dStep, bool bSplitArcs)
{
  // se non ho superfici da svuotare, non faccio nulla
   if ( vStepInfo.empty())
      return true ;

  // calcolo i percorsi di svuotatura per ogni Step/SubStep
   if ( ! CalcPaths( vStepInfo))
      return false ;

  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
  // elevazione sopra al punto attuale
   double dCurrElev ;
  // punto finale del percorso precedente al corrente
   Point3d ptEnd = P_INVALID ;

  // scorro il vettore dei piani di pocketing
   for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) {

     // riferimento alle informazioni relative allo step i-esimo
      StepInfoPO& currStep = vStepInfo[i] ;
     // scorro i percorsi calcolati per il piano di pocketing i-esimo
      for ( int j = 0 ; j < int( currStep.vPaths.size()) ; ++ j) {

        // riferimento alle informazioni relative al percorso j-esimo del piano di pocketing i-esimo
         PathInfoPO& currPath = currStep.vPaths[j] ;
        // ciclo sulle curve elementari del percorso attuale
         int nMaxInd = currPath.pCrvPath->GetCurveCount() - 1 ;
         for ( int k = 0 ; k <= nMaxInd ; ++ k) {

           // curva corrente
            const ICurve* pCrvC = currPath.pCrvPath->GetCurve( k) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
           // coefficiente feed ( riduzione di feed per sezione di taglio superiore al previsto )
            double dTempParam ; currPath.pCrvPath->GetCurveTempParam( k, dTempParam) ;
            double dCoeffFeed = min( 1., ( dTempParam > EPS_SMALL ? dTempParam /= 1000 : 1)) ;

           // se prima entità
            if ( k == 0) {
              // dati inizio entità
               Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
               Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
              // flag approccio libero in aria
               if ( currPath.bOutStart)
                  dCoeffFeed = ( dTempParam > EPS_SMALL ? dTempParam : 1) ;
              // calcolo ptP1 per LeadIn iniziale
               Point3d ptP1 ;
               if ( ! CalcLeadInStart( ptStart, vtTool, currPath.pCrvRet, ptP1)) {
                  m_pMchMgr->SetLastError( 3013, "Error in PocketingNT : LeadIn not computable") ;
                  return false ;
               }
              // determino l'elevazione sull'inizio dell'attacco della prima curva globale
               bool bAbsFirst = ( i == 0  &&  j == 0) ;
               if ( bAbsFirst)
                  dCurrElev = - currStep.dDepth ;
               dCurrElev -= ( ptP1 - ptStart) * vtTool ;
              // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
               if ( GetLeadInType() != POCKET_LI_NONE) {
                  double dMyLIO_ELEV_TOL = min( LIO_ELEV_TOL, dSafeZ) ;
                 // se prima entità in assoluto
                  if ( bAbsFirst) {
                     ptP1 += vtTool * ( dCurrElev + dMyLIO_ELEV_TOL) ;
                     dCurrElev = - min( LIO_ELEV_TOL, dSafeZ) ;
                  }
                 // altrimenti...
                  else if ( ! currPath.bOutStart)
                     ptP1 += vtTool * ( - currStep.dRelativeDepth + dMyLIO_ELEV_TOL) ;
               }
              // approccio al punto iniziale
               double dMySafeZ = ( bAbsFirst ? dSafeZ : 0.) ;
               Point3d ptMyPos ; GetCurrPos( ptMyPos) ;
               double dMyElev = ( bAbsFirst ? dCurrElev : ( ptMyPos - ptP1) * vtTool) ;
               double dMyAppr = ( bAbsFirst ? dAppr : 0.) ;
               if ( ! AddApproach( ptP1, vtTool, dMySafeZ, dSafeAggrBottZ, dMyElev, dMyAppr, bSplitArcs, currPath.bOutStart)) {
                  m_pMchMgr->SetLastError( 3011, "Error in PocketingNT : Approach not computable") ;
                  return false ;
               }
              // aggiungo attacco
               SetFeed( GetStartFeed()) ;
               bool bNoneForced = ( currPath.bOutStart  ||  currPath.bSingleCrv  ||
                                   ( m_Params.m_nSubType == POCKET_SUB_ZIGZAG  &&  ! currPath.bIsZigZagOneWayBorder)  ||
                                   ( m_Params.m_nSubType == POCKET_SUB_ONEWAY  &&  ! currPath.bIsZigZagOneWayBorder)) ;
               if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, currStep.pSfrPock,
                                 ( ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN  ||  m_Params.m_nSubType == POCKET_SUB_SPIRALOUT)) ? Get( currPath.pCrvRet) : nullptr,
                                 ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT) ? m_Params.m_bInvert : ! m_Params.m_bInvert,
                                 bSplitArcs, bNoneForced, false)) {
                  m_pMchMgr->SetLastError( 3013, "Error in PocketingNT : 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( dCoeffFeed * 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( dCoeffFeed * GetFeed()) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }

           // se ultima entità
            if ( k == nMaxInd) {
              // dati fine entità
               pCurve->GetEndPoint( ptEnd) ;
               Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
              // se sono l'ultima entità globale del percorso
               if ( i == int( vStepInfo.size()) - 1  &&  j == int( currStep.vPaths.size()) - 1) {
                 // aggiungo LeadOut
                  Point3d ptP1 ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtTool,
                                     ( ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN  ||  m_Params.m_nSubType == POCKET_SUB_SPIRALOUT)) ? Get( currPath.pCrvRet) : nullptr,
                                     bSplitArcs, false, ptP1)) {
                     m_pMchMgr->SetLastError( 3014, "Error in PocketingNT : LeadOut not computable") ;
                     return false ;
                  }
                 // aggiungo retroazione finale
                  if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, - currStep.dDepth, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 3015, "Error in PocketingNT : Retract not computable") ;
                     return false ;
                  }
               }
              // se ho un percorso successivo
               else {
                 // ricavo il punto che devo raggiungere e controllo la posizione del percorso successivo
                  bool bSamePlane = ( j < int( currStep.vPaths.size()) - 1) ;
                  bool bNextIsBelow = true ;
                  Point3d ptDest ;
                  if ( bSamePlane)
                     currStep.vPaths[j+1].pCrvPath->GetStartPoint( ptDest) ;
                  else {
                     vStepInfo[i+1].vPaths.front().pCrvPath->GetStartPoint( ptDest) ;
                     bNextIsBelow = ( ( ptDest - ptEnd) * vtTool < - 50 * EPS_SMALL) ;
                  }
                 // determino se un collegamento lineare tra i punti proiettati nel piano attuale è ammissibile
                  bool bSafe = false ;
                  if ( m_Params.m_nSubType != POCKET_SUB_ZIGZAG  &&  m_Params.m_nSubType != POCKET_SUB_ONEWAY) {
                     if ( ! CheckSafetyLinearLink( ptEnd,
                                                   ( bSamePlane ? currStep.pSfrLimit :
                                                                ( bNextIsBelow ? currStep.pSfrLimit : vStepInfo[i+1].pSfrLimit)),
                                                   vtTool, ptDest, bSafe))
                        return false ;
                  }
                 // determino l'elevazione sul punto corrente e sul punto di destinazione
                  dCurrElev = dSafeZ ;
                  double dNextElev = dSafeZ ;
                  if ( bSafe) {
                     if ( bSamePlane) {
                        if ( ( ( m_Params.m_nSubType == SURFROU_SUB_SPIRALIN  ||  m_Params.m_nSubType == SURFROU_SUB_SPIRALOUT) &&
                               ! vStepInfo[i].vPaths[j+1].bOutStart)  ||
                             ( m_Params.m_nSubType != SURFROU_SUB_SPIRALIN  &&  m_Params.m_nSubType != SURFROU_SUB_SPIRALOUT)) {
                           dCurrElev -= currStep.dRelativeDepth ;
                           dNextElev = dCurrElev ;
                        }
                     }
                     else if ( bNextIsBelow)
                        dNextElev += ( ptEnd - ptDest) * vtTool ;
                     else {
                        dCurrElev += ( ptDest - ptEnd) * vtTool  - currStep.dRelativeDepth ;
                        dNextElev -= currStep.dRelativeDepth ;
                     }
                  }
                  else {
                     dCurrElev -= currStep.dDepth ;
                     if ( bSamePlane)
                        dNextElev -= currStep.dDepth ;
                     else
                        dNextElev -= vStepInfo[i+1].dDepth ;
                  }
                 // tratto lineare sopra al punto corrente
                  SetFeed( GetEndFeed()) ;
                  AddLinearMove( ptEnd + vtTool * dCurrElev) ;
                 // tratto lineare sopra a ptDest
                  AddLinearMove( ptDest + vtTool * dNextElev) ;
                 // aggiorno le elevazioni
                  dCurrElev = dNextElev ;
               }
            }
         }
      }
   }

  // aggiorno per sicurezza la ProgressBar nel caso di Step vuoti
   ExeProcessEvents( 100, 0) ;
   return true ;
}

//----------------------------------------------------------------------------
double
PocketingNT::GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool)
{
  // 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)) ;
}

//----------------------------------------------------------------------------
static double
GetCurveRadius( const ICurve* pCrv)
{
   if ( pCrv == nullptr)
      return 0.0 ;
   BBox3d b3Loc ;
   if ( ! pCrv->GetLocalBBox( b3Loc, BBF_EXACT))
      return 0.0 ;
   double dRad ;
   if ( ! b3Loc.GetRadius( dRad))
      return 0.0 ;
   return dRad ;
}

//------------------------------------------------------------------
bool
PocketingNT::CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB)
{
   IntersCurveCurve IntersCC( *pCrvA, *pCrvB) ;
   CRVCVECTOR ccClass ;
   IntersCC.GetCurveClassification( 1, EPS_SMALL, ccClass) ;

   if ( ccClass.size() != 3  ||  ccClass[0].nClass != CRVC_OUT  ||  ccClass[1].nClass == CRVC_OUT  ||  ccClass[2].nClass != CRVC_OUT)
      return false ;

   Point3d ptS, ptE ;
   pCrvB->GetPointD1D2( ccClass[1].dParS, ICurve::FROM_MINUS, ptS) ;
   pCrvB->GetPointD1D2( ccClass[1].dParE, ICurve::FROM_MINUS, ptE) ;
   double dParS, dParE ;
   pCrvA->GetParamAtPoint( ptS, dParS) ;
   pCrvA->GetParamAtPoint( ptE, dParE) ;

   PtrOwner<ICurveComposite> pCrvTmp( CloneCurveComposite( pCrvA)) ;
   if ( IsNull( pCrvTmp))
      return false ;
   pCrvA->Clear() ;
   pCrvA->AddCurve( pCrvB->CopyParamRange( ccClass[1].dParS, ccClass[1].dParE)) ;
   pCrvA->AddCurve( pCrvTmp->CopyParamRange( dParE, dParS)) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs)
{
   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
   PtrOwner<ICurveComposite> pCrvBound( CreateCurveComposite()) ;   // curva bound da usare per CalcBoundedLink
   ICRVCOMPOPOVECTOR vpCrvsEp ;

   Frame3d frLoc ;
   Vector3d vtExtr ; pMCrv->GetExtrusion( vtExtr) ;
   frLoc.Set( ORIG, vtExtr) ;
   pMCrv->ToLoc( frLoc) ;

   for ( int i = 0 ; i < pMCrv->GetCurveCount() ; i ++) {
      int nProp = 0 ;
      if ( ! pMCrv->GetCurveTempProp( i, nProp))
         return false ;

     // se è un tratto di collegamento ho concluso percorso su cui aggiungere epicicli
      if ( nProp == LINK_CURVE_PROP) {
         if ( pCompo->IsValid()) {
            PtrOwner<ICurveComposite> pCrvEp( CreateCurveComposite()) ;
           // la curva di bound è l'offset che calcolo in AddEpicycles per la prima curva compo trovata in pMCrv
            bool bAddEp = ( ! pCrvBound->IsValid()) ? AddEpicycles( pCompo, pCrvEp, pCrvBound) : AddEpicycles( pCompo, pCrvEp) ;
            if ( ! bAddEp)
               return false ;
            vpCrvsEp.emplace_back( Release( pCrvEp)) ;
            pCompo.Set( CreateCurveComposite()) ;
         }
      }
     // se non è tratto di collegamento lo aggiungo alla curva
      else {
         if ( ! pCompo->AddCurve( pMCrv->GetCurve(i)->Clone()))
            return false ;
      }
   }

  // ultima curva 
   if ( ! IsNull( pCompo)) {
      PtrOwner<ICurveComposite> pCrvEp( CreateCurveComposite()) ;
      if ( ! AddEpicycles( pCompo, pCrvEp))
         return false ;
      vpCrvsEp.emplace_back( Release( pCrvEp)) ;
   }

  // calcolo i collegamenti
   ICURVEPOVECTOR vLinks( vpCrvsEp.size()) ;
   for ( int i = 1 ; i < int( vpCrvsEp.size()) ; ++ i) {
     // punti e direzioni di inizio e fine
      Point3d ptStart ; Vector3d vtStart ;
      vpCrvsEp[i-1]->GetEndPoint( ptStart) ;
      vpCrvsEp[i-1]->GetEndDir( vtStart) ;
      Point3d ptEnd ; Vector3d vtEnd ;
      vpCrvsEp[i]->GetStartPoint( ptEnd) ;
      vpCrvsEp[i]->GetStartDir( vtEnd) ;

     // calcolo il collegamento con biarchi (garantendo che non esca dalla svuotatura)
      PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
      if ( CalcBoundedLinkWithBiArcs( ptStart, vtStart, ptEnd, vtEnd, pCrvBound, pCrvLink)) {
         vLinks[i].Set( pCrvLink) ;
      }
      else {
         m_pMchMgr->SetLastError( 2413, "Error in PocketingNT : Toolpath not computable") ;
         return false ;
      }
   }

  // calcolo il percorso di ritorno
   pRCrv->Clear() ;
   if ( vpCrvsEp.size() >= 2) {
     // punti di inizio e fine
      Point3d ptStart ; Vector3d vtStart ;
      vpCrvsEp.back()->GetEndPoint( ptStart) ;
      vpCrvsEp.back()->GetEndDir( vtStart) ;
      Point3d ptEnd ; Vector3d vtEnd ;
      vpCrvsEp.front()->GetStartPoint( ptEnd) ;
      vpCrvsEp.front()->GetStartDir( vtEnd) ;

     // calcolo il ritorno con biarchi (garantendo che non esca dalla svuotatura)
      PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
      if ( CalcBoundedLinkWithBiArcs( ptStart, vtStart, ptEnd, vtEnd, pCrvBound, pCrvLink)) {
         pRCrv->AddCurve( Release( pCrvLink)) ;
         pRCrv->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false) ;
        // se necessario, approssimo archi con rette
         if ( bSplitArcs  &&  ! ApproxWithLines( pRCrv)) {
            m_pMchMgr->SetLastError( 2419, "Error in PocketingNT : Linear Approx not computable") ;
            return false ;
         }
         VerifyArcs( pRCrv) ;
      }
      else {
         m_pMchMgr->SetLastError( 2413, "Error in PocketingNT : Toolpath not computable") ;
         return false ;
      }
   }

  // creo il percorso di lavoro a partire dalla raccolta delle curve con epicicli e dei collegamenti
   pMCrv->Clear() ;
   for ( int i = 0 ; i < int( vpCrvsEp.size()) ; ++ i) {
     // se collegamento da aggiungere
      if ( ! IsNull( vLinks[i])) { 
        // accodo nel percorso di lavorazione
         pMCrv->AddCurve( Release( vLinks[i])) ;
      }
     // aggiungo la curva
      pMCrv->AddCurve( Release( vpCrvsEp[i])) ;
   }

  // se necessario, approssimo archi con rette
   if ( bSplitArcs  &&  ! ApproxWithLines( pMCrv)) {
      m_pMchMgr->SetLastError( 2419, "Error in PocketingNT : Linear Approx not computable") ;
      return false ;
   }
   VerifyArcs( pMCrv) ;

   pMCrv->ToGlob( frLoc) ;
   pRCrv->ToGlob( frLoc) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddEpicycles( ICurveComposite* pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound)
{
   if ( m_Params.m_bInvert)
      pCompo->Invert() ;    // oriento la curva in senso antiorario 

   OffsetCurve OffsCrv ;
   double dOffs = m_Params.m_dEpicyclesRad ;
   if ( ! OffsCrv.Make( pCompo, dOffs, ICurve::OFF_FILLET)) {
      m_pMchMgr->SetLastError( 2412, "Error in PocketingNT : Offset not computable") ;
      return false ;
   }
   if ( OffsCrv.GetCurveCount() > 1)
      return false ;
   PtrOwner<ICurveComposite> pCrvOffs( GetCurveComposite( OffsCrv.GetCurve())) ;
   if ( IsNull( pCrvOffs))
      return false ;

  // verifico se devo resitituire la curva offsettata 
   if ( pCrvBound)
      pCrvBound->AddCurve( pCrvOffs->Clone()) ;

   pCrv->Clear() ;
   double dParPrec = 0 ; 
   for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) {

     // calcolo distanza epicili specifica per quel tratto
      double dLen ;
      pCompo->GetCurve( i)->GetLength( dLen) ;
      int nStep = max( 1, static_cast<int>( ceil( ( dLen) / m_Params.m_dEpicyclesDist))) ;
      double dStep = 1.0 / nStep ; 

      for ( int k = 1 ; k <= nStep ; k ++) {
        // creo epiciclo 
         PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
         Point3d ptCen ;
         Vector3d vtDir ;
         pCompo->GetCurve( i)->GetPointD1D2( k * dStep, ICurve::FROM_MINUS, ptCen, &vtDir) ;
         vtDir.Normalize() ;
         vtDir.Rotate( Z_AX, - 90) ;
         Point3d pt = ptCen + vtDir * m_Params.m_dEpicyclesRad ;
         pCrvArc->Set(  ptCen, Z_AX, m_Params.m_dEpicyclesRad) ;
         double dU ;
         pCrvArc->GetParamAtPoint( pt, dU) ;
         pCrvArc->ChangeStartPoint( dU) ; 

        // aggiungo tratto della curva offsettata
         double dPar ;
         pCrvOffs->GetParamAtPoint( pt, dPar) ; 
         bool bAdd = pCrv->AddCurve( pCrvOffs->CopyParamRange( dParPrec, dPar)) ;

        // aggiungo epiciclo 
         if ( ! pCrv->AddCurve( Release( pCrvArc))) { 
           // se fallisco nell'aggiungere l'epiciclo tento nuovamente spostandolo di EPS_SMALL
            if ( bAdd)
               PtrOwner<ICurve> pCrvErased( pCrv->RemoveFirstOrLastCurve( true)) ;
            k -- ;
            dStep -= EPS_SMALL ;
            if ( dStep < EPS_SMALL)
               return false ;
         }
         else
            dParPrec = dPar ;
      }
   }
  // se necessario ripristino orientamento originale
   if ( m_Params.m_bInvert)
      pCrv->Invert() ;

   return true ;
}

//------------------------------------------------------------------------------
bool 
PocketingNT::CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd,
                                      const ICurve* pCrvBound, ICurveComposite* pCrvLink)
{
   double dAngStart, dAngEnd ;
   vtStart.GetAngleXY( X_AX, dAngStart) ;
   vtEnd.GetAngleXY( X_AX, dAngEnd) ;
   PtrOwner<ICurve> pBiArcLink( GetBiArc( ptStart, -dAngStart, ptEnd, -dAngEnd, 0.5)) ;
   if ( IsNull( pBiArcLink))
      return false ;

  // verifico se esce dalla svuotatura
   CRVCVECTOR ccClass ;
   IntersCurveCurve intCC( *pBiArcLink, *pCrvBound) ;
   intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
  // se nessuno o un solo tratto e interno, il biarco è il collegamento
   if ( ccClass.empty()  ||  ( ccClass.size() == 1  &&  ccClass[0].nClass == CRVC_IN)) {
      pCrvLink->AddCurve( Release( pBiArcLink)) ;
   }
  // altrimenti creo un percorso con biarchi e opportuni tratti della curva di contenimento
   else {
      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
      if ( IsNull( pCompo))
         return false ;

      double dPar1, dPar2 ;
      Point3d ptMinDist1, ptMinDist2 ; 
      Vector3d vtDir1, vtDir2 ;
      double dAng1, dAng2 ;
      int nFlag ;

      DistPointCurve distPtSCrv( ptStart, *pCrvBound) ;
      distPtSCrv.GetParamAtMinDistPoint( 0, dPar1, nFlag) ;
      pCrvBound->GetPointTang( dPar1, ICurve::FROM_MINUS, ptMinDist1, vtDir1) ;
      vtDir1.GetAngleXY( X_AX, dAng1) ;

      DistPointCurve distPtECrv( ptEnd, *pCrvBound) ;
      distPtECrv.GetParamAtMinDistPoint( 0, dPar2, nFlag) ;
      pCrvBound->GetPointTang( dPar2, ICurve::FROM_MINUS, ptMinDist2, vtDir2) ;
      vtDir2.GetAngleXY( X_AX, dAng2) ;

      pCompo->AddCurve( GetBiArc( ptStart, -dAngStart, ptMinDist1, -dAng1, 0.5)) ;  // primo biarco
      pCompo->AddCurve( pCrvBound->CopyParamRange( dPar1, dPar2)) ;                 // tratto di pCrvBound
      pCompo->AddCurve( GetBiArc( ptMinDist2, -dAng2, ptEnd, -dAngEnd, 0.5)) ;      // secondo biarco

      pCrvLink->AddCurve( Release( pCompo)) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                          double dElev, double dAppr, bool bSplitArcs, bool bOutStart)
{
   SetFlag( 1) ;
  // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
   bool bBottomOutStart = false ;
   if ( m_bAggrBottom) {
     // distanza dal bordo del pezzo (se negativa il punto è fuori dal grezzo)
      double dDistBottom ;
      if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
         dDistBottom = 0 ;
      bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
     // aggiuntivo in Z
      double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
     // pre-approccio
      Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
     // se richiede speciale rotazione
      if ( m_AggrBottom.nType == 1) {
        // punto ruotato
         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
         Vector3d vtAux = m_vtAggrBottom ;
         vtAux.Rotate( Z_AX, 0, 1) ;
         SetAuxDir( vtAux) ;
         if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
            return false ;
        // vado al punto standard
         SetAuxDir( m_vtAggrBottom) ;
         SetFlag( 0) ;
         if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
            return false ;
      }
     // se altrimenti con rotazione per minimizzare la sporgenza
      else if ( m_AggrBottom.nType == 3) {
        // punto standard ruotato
         Vector3d vtAux = m_vtAggrBottom ;
         vtAux.Rotate( Z_AX, 0, 1) ;
         SetAuxDir( vtAux) ;
         if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
            return false ;
        // la rotazione viene eseguita nel movimento successivo al punto sopra l'inizio lavorazione
         SetAuxDir( m_vtAggrBottom) ;
         SetFlag( 0) ;
      }
     // altrimenti rinvio normale
      else {
         SetAuxDir( m_vtAggrBottom) ;
         if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
            return false ;
         SetFlag( 0) ;
      }
   }
  // se sopra attacco c'è spazio per sicurezza o approccio
   double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
   if ( ! bBottomOutStart  &&  dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
      Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
     // se distanza di sicurezza minore di distanza di inizio
      if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
        // 1 -> punto sopra inizio
         if ( AddRapidStartOrMove( ptP1, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
      else {
        // 1a -> punto molto sopra inizio
         Point3d ptP1a = ptP1 + vtTool * ( dSafeDist - dAppr) ;
         if ( AddRapidStartOrMove( ptP1a, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
            return false ;
        // 1 -> punto sopra inizio
         if ( ( dElev + dAppr) > 10 * EPS_SMALL  ||  (( dElev + dAppr) > -EPS_ZERO  &&  dAppr > EPS_SMALL)) {
            SetFlag( 0) ;
            if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
               return false ;
         }
         else
            ptP1 = ptP1a ;
      }
     // affondo al punto iniziale
      SetFlag( 0) ;
      bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP) ;
      SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
   else {
     // affondo diretto al punto iniziale
      SetFlag( 0) ;
      if ( AddRapidStartOrMove( ptP, ! m_bAggrBottom, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                            double dElev, double dAppr, bool bSplitArcs, bool bOutStart)
{
  // 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, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
     // affondo al punto iniziale
      SetFlag( 0) ;
      SetFeed( bOutStart ? GetStartFeed() : GetTipFeed()) ;
      if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
   else {
     // affondo diretto al punto iniziale
      SetFlag( 0) ;
      if ( AddRapidMove( ptP, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                           double dElev, double dAppr, bool bSplitArcs)
{
  // 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, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                       double dElev, double dAppr, bool bSplitArcs)
{
  // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
   bool bBottomOutStart = false ;
   double dDistBottom ;
   if ( m_bAggrBottom) {
     // distanza dal bordo del pezzo
      if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
         dDistBottom = 0 ;
      bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
   }
  // se sopra uscita c'è spazio per sicurezza o approccio
   double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
   if ( ! bBottomOutStart  &&  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, bSplitArcs) == 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, bSplitArcs) == GDB_ID_NULL)
               return false ;
         }
        // 4b -> movimento di risalita sopra il punto finale
         Point3d ptP4b = ptP4a + vtTool * ( dSafeDist - dAppr) ;
         if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
   }
  // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
   if ( m_bAggrBottom) {
     // se con rotazione per minimizzare la sporgenza
      if ( m_AggrBottom.nType == 3) {
        // imposto rotazione su punto standard
         Vector3d vtAux = m_vtAggrBottom ;
         vtAux.Rotate( Z_AX, 0, 1) ;
         SetAuxDir( vtAux) ;
      }
     // aggiuntivo in Z
      double dAggZ = ( bBottomOutStart ? 0. : max( dElev + max( dSafeAggrBottZ, dAppr), 0.)) ;
     // post-retract
      Point3d ptP0 = ptP - Z_AX * dAggZ + m_vtAggrBottom * ( dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
      if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
         return false ;
      // se richiede speciale rotazione
      if ( m_AggrBottom.nType == 1) {
         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAggZ - dElev) ;
         Vector3d vtAux = m_vtAggrBottom ;
         vtAux.Rotate( Z_AX, 0, 1) ;
         SetAuxDir( vtAux) ;
         if ( AddRapidMove( ptP00, bSplitArcs, MCH_CL_AGB_UP) == GDB_ID_NULL)
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtTool,
                               const ICurveComposite* pRCrv, Point3d& ptP1)
{
  // Assegno tipo e parametri
   int nType = GetLeadInType() ;
   if ( nType == SURFROU_LI_GLIDE  &&  ( pRCrv == nullptr  ||  pRCrv->GetCurveCount() == 0))
      nType = SURFROU_LI_NONE ;
  // Calcolo punto iniziale
   switch ( nType) {
   case SURFROU_LI_NONE :
   case SURFROU_LI_ZIGZAG :
   case SURFROU_LI_HELIX :
      ptP1 = ptStart ;
      return true ;
   case SURFROU_LI_GLIDE :
      {
         double dLen, dU ;
         if ( ! pRCrv->GetLength( dLen)  ||  ! pRCrv->GetParamAtLength( dLen - m_Params.m_dLiTang, dU)  ||
              ! pRCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
            if ( ! pRCrv->GetStartPoint( ptP1))
               return false ;
         }
         ptP1 += vtTool * ( vtTool * ( ptStart - ptP1)) ;
         return true ;
      }
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                        const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
                        bool bNoneForced, bool bSkipControl)
{
  // Assegno il tipo
   int nType = GetLeadInType() ;
   if ( bNoneForced  ||
        AreSamePointEpsilon( ptP1, ptStart, 10 * EPS_SMALL)  ||
        ( nType == POCKET_LI_GLIDE  &&  ( pRCrv == nullptr  ||  pRCrv->GetCurveCount() == 0)))
      nType = POCKET_LI_NONE ;
  // Se elica e fattibile lo creo
   if ( nType == POCKET_LI_HELIX) {
     // vettore dal punto al centro elica
      Vector3d vtCen = vtStart ;
      vtCen.Rotate( vtN, 0, ( bAtLeft ? 1 : - 1)) ;
     // dati dell'elica
      double dRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), m_dMaxHelixRad) ;
      Point3d ptCen = ptP1 + vtCen * dRad ;
      double dDeltaN = ( ptStart - ptP1) * vtN ;
      double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 20 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
     // verifico se fattibile
      if ( bSkipControl  ||  VerifyLeadInHelix( pSfr, ptStart, ptCen, dRad)) {
        // creo l'elica
         PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
         if ( IsNull( pArc)  ||  ! pArc->Set( ptCen, vtN, dRad, - vtCen, dAngCen, dDeltaN))
            return false ;
        // emetto l'elica (con eventuale spezzatura)
         return ( AddCurveMove( pArc, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
     // altrimenti zigzag
      else
         nType = POCKET_LI_ZIGZAG ;
   }
  // Se zigzag e fattibile lo creo
   if ( nType == POCKET_LI_ZIGZAG) {
     // dati dello zigzag
      double dDeltaN = ( ptStart - ptP1) * vtN ;
      int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 20 * EPS_SMALL))) ;
      double dStep = - dDeltaN / nStep ;
      Point3d ptPa = ptP1 + vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
      Point3d ptPb = ptP1 - vtStart * 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
     // verifico se fattibile
      if ( bSkipControl  ||  VerifyLeadInZigZag( pSfr, ptStart, ptPa, ptPb)) {
         for ( int i = 1 ; i <= nStep ; ++ i) {
            if ( AddLinearMove( ptPa - vtN * ( i - 0.75) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
            if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
         }
         return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
     // altrimenti diretto
      else {
         nType = POCKET_LI_NONE ;
         if ( m_TParams.m_nType == TT_MILL_NOTIP)
            return false ;
      }
   }
  // Se a scivolo e fattibile
   if ( nType == POCKET_LI_GLIDE) {
      if ( pRCrv != nullptr) {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         double dLen, dU ;
         if ( pRCrv->GetLength( dLen)  &&  pRCrv->GetParamAtLength( dLen - m_Params.m_dLiTang, dU)) {
            double dParS, dParE ;
            pRCrv->GetDomain( dParS, dParE) ;
            if ( ! pCrv.Set( ConvertCurveToComposite( pRCrv->CopyParamRange( dU, dParE))))
               return false ;
         }
         else {
            if ( ! pCrv.Set( pRCrv->Clone()))
               return false ;
         }
         pCrv->SetExtrusion( vtN) ;
        // la porto alla giusta quota
         Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
         Vector3d vtMove = ptStart - ptFin ;
         pCrv->Translate( vtMove) ;
        // assegno la corretta pendenza
         double dNini = ( ptP1 - ORIG) * vtN ;
         double dNfin = ( ptStart - ORIG) * vtN ;
         AdjustCurveSlope( pCrv, dNini, dNfin) ;
        // emetto (con eventuale spezzatura)
         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
     // altrimenti diretto
      else
         nType = POCKET_LI_NONE ;
   }
  // Se diretto
   if ( nType == POCKET_LI_NONE) {
      Point3d ptCurr = ptP1 ;
      GetCurrPos( ptCurr) ;
      if ( ! AreSamePointApprox( ptCurr, ptStart)) {
         if ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
            return false ;
      }
      return true ;
   }
  // Altrimenti errore
   return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                         const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
                         Point3d& ptP1)
{
  // assegno i parametri
   int nType = GetLeadOutType() ;
   if ( bNoneForced  ||
        ( nType == POCKET_LO_GLIDE  &&  ( pRCrv == nullptr  ||  pRCrv->GetCurveCount() == 0)))
      nType = POCKET_LO_NONE ;
  // eseguo a seconda del tipo
   switch ( nType) {
   case POCKET_LO_NONE :
      {
        // nessuna uscita
         ptP1 = ptEnd ;
         return true ;
      }
   case POCKET_LO_GLIDE :
      {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         double dU ;
         if ( pRCrv->GetParamAtLength( m_Params.m_dLoTang, dU)) {
            if ( ! pCrv.Set( ConvertCurveToComposite( pRCrv->CopyParamRange( 0, dU))))
               return false ;
         }
         else {
            if ( ! pCrv.Set( pRCrv->Clone()))
               return false ;
         }
        // la porto alla giusta quota
         Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
         Vector3d vtMove = ptEnd - ptIni ;
         pCrv->Translate( vtMove) ;
         Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
         ptFin += vtN * 1.0 ;
         pCrv->ModifyEnd( ptFin) ;
        // emetto (con eventuale spezzatura)
         AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) ;
        // determino elevazione su fine uscita
         ptP1 = ptFin ;
         return true ;
      }
   default :
      return false ;
   }

}

//----------------------------------------------------------------------------
double
PocketingNT::GetRadiusForStartEndElevation( void)
{
   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) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GetForcedClosed( void)
{
   int nOpen ;
   if ( GetValInNotes( m_Params.m_sUserNotes, "Open", nOpen)  &&  nOpen == 0)
      return true ;
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GetMidOfLongestOpenSide( const ICurveComposite* pCompo, Point3d& ptMid, Vector3d& vtMidOrt)
{
  // recupero il vettore estrusione
   Vector3d vtExtr = Z_AX ;
   pCompo->GetExtrusion( vtExtr) ;
  // verifico se tutti i lati sono aperti
   bool bAllOpen = true ;
   const ICurve* pMyCrv = pCompo->GetFirstCurve() ;
   while ( pMyCrv != nullptr) {
      if ( pMyCrv->GetTempProp() != 1) {
         bAllOpen = false ;
         break ;
      }
      pMyCrv = pCompo->GetNextCurve() ;
   }
  // richiedo lunghezza superiore a diametro utensile più doppio offset radiale
   double dRefLen = ( bAllOpen ? 0 : m_TParams.m_dDiam + 2 * GetOffsR() - EPS_SMALL) ;
   double dMaxLen = dRefLen ;
  // ciclo sulle singole curve
   bool bFound = false ;
   const ICurve* pPrevCrv = pCompo->GetLastCurve() ;
   double dLenPrev = 0 ;
   if ( pPrevCrv != nullptr  &&  pPrevCrv->GetTempProp() == 1)
      pPrevCrv->GetLength( dLenPrev) ;
   const ICurve* pCrv = pCompo->GetFirstCurve() ;
   while ( pCrv != nullptr) {
     // analizzo la curva successiva
      const ICurve* pNextCrv = pCompo->GetNextCurve() ;
      bool bNextOk = ( pNextCrv != nullptr) ;
      if ( ! bNextOk)
         pNextCrv = pCompo->GetFirstCurve() ;
      double dLenNext = 0 ;
      if ( pNextCrv != nullptr  &&  pNextCrv->GetTempProp() == 1)
         pNextCrv->GetLength( dLenNext) ;
     // verifico la curva corrente
      if ( pCrv->GetTempProp() == 1) {
        // contributo dalle entità adiacenti (se non tutte aperte)
         double dLenAgg = 0 ;
         if ( ! bAllOpen) {
            if ( pPrevCrv != nullptr  &&  pPrevCrv->GetTempProp() == 1) {
               Vector3d vtPrevEnd ;  pPrevCrv->GetEndDir( vtPrevEnd) ;
               Vector3d vtStart ;  pCrv->GetStartDir( vtStart) ;
               dLenAgg += max( 0.4, vtPrevEnd * vtStart) * dLenPrev ;
            }
            if ( pNextCrv != nullptr  &&  pNextCrv->GetTempProp() == 1) {
               Vector3d vtEnd ;  pCrv->GetEndDir( vtEnd) ;
               Vector3d vtNextStart ;  pNextCrv->GetStartDir( vtNextStart) ;
               dLenAgg += max( 0.4, vtEnd * vtNextStart) * dLenNext ;
            }
         }
        // entità corrente
         double dLen = 0 ;
         if ( pCrv->GetLength( dLen)) {
            const double LEN_TOL = 1 ;
           // se di lunghezza praticamente uguale
            if ( bFound  &&  dLen + dLenAgg > dRefLen  &&  abs( dLen + dLenAgg - dMaxLen) < LEN_TOL) {
               Point3d ptTest ;
               pCrv->GetMidPoint( ptTest) ;
               if ( ( m_bAboveHead  &&  ptTest.z > ptMid.z + 100 * EPS_SMALL)  ||
                    ( ! m_bAboveHead  &&  ptTest.z < ptMid.z - 100 * EPS_SMALL) ||
                    ( abs( ptTest.z - ptMid.z) < 100 * EPS_SMALL  &&  ptTest.y < ptMid.y - 100 * EPS_SMALL)) {
                  dMaxLen = max( dMaxLen, dLen + dLenAgg) ;
                  ptMid = ptTest ;
                 // vettore ortogonale verso l'esterno (ruotato -90deg attorno a estrusione)
                  pCrv->GetMidDir( vtMidOrt) ;
                  vtMidOrt.Rotate( vtExtr, 0, -1) ;
               }
            }
           // se più lunga
            else if ( dLen + dLenAgg > dMaxLen) {
               dMaxLen = dLen + dLenAgg ;
               pCrv->GetMidPoint( ptMid) ;
              // vettore ortogonale verso l'esterno (ruotato -90deg attorno a estrusione)
               pCrv->GetMidDir( vtMidOrt) ;
               vtMidOrt.Rotate( vtExtr, 0, -1) ;
               bFound = true ;
            }
            dLenPrev = dLen ;
         }
      }
      else
         dLenPrev = 0 ;
     // vado alla successiva
      pPrevCrv = pCrv ;
      pCrv = ( bNextOk ? pNextCrv : nullptr) ;
   }

   return bFound ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AdjustContourWithOpenEdges( ICurveComposite* pCompo)
{
  // vettore estrusione
   Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
  // calcolo riferimento nel piano della svuotatura
   Frame3d frPocket ;
   Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
   frPocket.Set( ptStart, vtExtr) ;
  // sposto l'inizio a metà del tratto più lungo
   AdjustContourStart( pCompo) ;
  // raggio di riferimento per offset
   double dOutEdge = 0.5 * m_TParams.m_dDiam ;
   if ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN  ||  m_Params.m_nSubType == POCKET_SUB_ZIGZAG)
      dOutEdge = max( dOutEdge, m_TParams.m_dDiam - m_Params.m_dSideStep) ; 
   double dRad = dOutEdge + GetOffsR() ;
  // estraggo parti con proprietà uniforme in un vettore
   ICURVEPOVECTOR vpCrvs ;
   int nCurrTempProp ;
   int nParStart = 0 ;
   for ( int i = 0 ; i < pCompo->GetCurveCount() ; ++ i) {
      int nTempProp ;
      pCompo->GetCurveTempProp( i, nTempProp) ;
      if ( i == 0) {
         nCurrTempProp = nTempProp ;
         nParStart = i ;
      }
      else if ( nCurrTempProp != nTempProp) {
         PtrOwner<ICurve> pCrv( pCompo->CopyParamRange( nParStart, i)) ;
         if ( IsNull( pCrv))
            return false ;
         pCrv->SetTempProp( nCurrTempProp) ;
         pCrv->SetExtrusion( vtExtr) ;
         vpCrvs.emplace_back( Release( pCrv)) ;
         nCurrTempProp = nTempProp ;
         nParStart = i ;
      }
   }
   PtrOwner<ICurve> pCrv( pCompo->CopyParamRange( nParStart, pCompo->GetCurveCount())) ;
   if ( IsNull( pCrv))
      return false ;
   pCrv->SetTempProp( nCurrTempProp) ;
   pCrv->SetExtrusion( vtExtr) ;
   vpCrvs.emplace_back( Release( pCrv)) ;
  // offsetto del raggio le curve aperte
   for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
      if ( vpCrvs[i]->GetTempProp() == 1) {
         OffsetCurve OffsCrv ;
         if ( ! OffsCrv.Make( vpCrvs[i], dRad, ICurve::OFF_FILLET)  ||  OffsCrv.GetCurveCount() == 0) {
            m_pMchMgr->SetLastError( 2412, "Error in PocketingNT : Offset not computable") ;
            return false ;
         }
         vpCrvs[i].Set( OffsCrv.GetLongerCurve()) ;
         vpCrvs[i]->SetTempProp( 1) ;
      }
   }
  // reinserisco le curve, chiudendo eventuali gap
   pCompo->Clear() ;
   pCompo->SetExtrusion( vtExtr) ;
   bool bOpenCurr = false ;
   double dDiam = 1.05 * m_TParams.m_dDiam + 2 * GetOffsR() ;
   for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
     // stato curve
      bool bOpenPrev = bOpenCurr ;
      bOpenCurr = ( vpCrvs[i]->GetTempProp() != 0) ;
     // chiudo eventuale gap
      if ( i > 0) {
         Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;
         Point3d ptStart ; vpCrvs[i]->GetStartPoint( ptStart) ;
         if ( ! AreSamePointEpsilon( ptEnd, ptStart, 10 * EPS_SMALL)) {
           // se passo da chiuso ad aperto
            if ( ! bOpenPrev  &&  bOpenCurr) {
              // determino la curva ad amo
               Vector3d vtTg ; pCompo->GetEndDir( vtTg) ;
               Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, 1) ;
               Point3d ptArc = ptEnd + dDiam * vtOrt ;
               Point3d ptLine = ptArc - 5 * dDiam * vtTg ;
               PtrOwner<ICurveComposite> pJCrv( CreateCurveComposite()) ;
               if ( IsNull( pJCrv))
                  return false ;
               pJCrv->SetExtrusion( vtExtr) ;
               pJCrv->AddPoint( ptLine) ;
               pJCrv->AddLine( ptArc, false) ;
               pJCrv->AddArcTg( ptEnd, false) ;
              // calcolo l'intersezione nel piano della svuotatura dell'amo con la curva aperta
               pJCrv->ToLoc( frPocket) ;
               vpCrvs[i]->ToLoc( frPocket) ;
               IntersCurveCurve intCC( *pJCrv, *vpCrvs[i]) ;
               pJCrv->ToGlob( frPocket) ;
               vpCrvs[i]->ToGlob( frPocket) ;
              // taglio opportunamente le curve
               bool bFound = false ;
               IntCrvCrvInfo aInfo ;
               if ( intCC.GetIntersCount() > 0) {
                 // cerco la prima intersezione che entra nella curva aperta
                  for ( int j = 0 ; j < intCC.GetIntersCount() ; ++ j) {
                     if ( intCC.GetIntCrvCrvInfo( j, aInfo)  &&  aInfo.IciA[0].nPrevTy == ICCT_OUT) {
                        bFound = true ;
                        break ;
                     }
                  }
               }
               if ( bFound) {
                  pJCrv->TrimEndAtParam( aInfo.IciA[0].dU) ;
                  vpCrvs[i]->TrimStartAtParam( aInfo.IciB[0].dU)  ;
                  pCompo->AddCurve( ::Release( pJCrv), true, 10 * EPS_SMALL) ;
               }
               else
                  pCompo->AddLine( ptStart) ;
            }
           // se passo da aperto a chiuso
            else if ( bOpenPrev  &&  ! bOpenCurr) {
              // determino la curva ad amo
               Vector3d vtTg ; vpCrvs[i]->GetStartDir( vtTg) ;
               Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, 1) ;
               Point3d ptArc = ptStart + dDiam * vtOrt ;
               Point3d ptLine = ptArc + 5 * dDiam * vtTg ;
               PtrOwner<ICurveComposite> pJCrv( CreateCurveComposite()) ;
               if ( IsNull( pJCrv))
                  return false ;
               pJCrv->SetExtrusion( vtExtr) ;
               pJCrv->AddPoint( ptLine) ;
               pJCrv->AddLine( ptArc) ;
               pJCrv->AddArcTg( ptStart) ;
              // calcolo l'intersezione nel piano della svuotatura dell'amo con la curva aperta
               PtrOwner<ICurveComposite> pLCrv( CreateCurveComposite()) ;
               if ( IsNull( pLCrv))
                  return false ;
               pLCrv->AddCurve( pCompo->GetLastCurve()->Clone()) ;
               if ( pCompo->GetCurveCount() >= 2)
                  pLCrv->AddCurve( pCompo->GetPrevCurve()->Clone(), false) ;
               double dUL = pLCrv->GetCurveCount() ;
               pJCrv->ToLoc( frPocket) ;
               pLCrv->ToLoc( frPocket) ;
               IntersCurveCurve intCC( *pJCrv, *pLCrv) ;
               pJCrv->ToGlob( frPocket) ;
               pLCrv->ToGlob( frPocket) ;
              // taglio opportunamente le curve
               IntCrvCrvInfo aInfo ;
               if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) {
                  double dUs, dUe ; pCompo->GetDomain( dUs, dUe) ;
                  pCompo->TrimEndAtParam( dUe - dUL + aInfo.IciB[0].dU)  ;
                  pJCrv->TrimStartAtParam( aInfo.IciA[0].dU) ;
                  pCompo->AddCurve( ::Release( pJCrv), true, 10 * EPS_SMALL) ;
               }
               else
                  pCompo->AddLine( ptStart) ;
            }
            else
               pCompo->AddLine( ptStart) ;
         }
      }
     // aggiungo la curva
      pCompo->AddCurve( ::Release( vpCrvs[i]), true, 10 * EPS_SMALL) ;
   }
  // non dovrebbe esserci un gap, ma meglio prevenire problemi
   pCompo->Close() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::AdjustContourStart( ICurveComposite* pCompo)
{
  // cerco il tratto lineare più lungo che non sia aperto
   int i = 0 ;
   int nMax = - 1 ;
   double dLenMax = 0 ;
   const ICurve* pCrv = pCompo->GetFirstCurve() ;
   while ( pCrv != nullptr) {
      double dLen ;
      if ( pCrv->GetType() == CRV_LINE  &&  pCrv->GetTempProp() == 0  &&  pCrv->GetLength( dLen)  &&  dLen > dLenMax) {
         dLenMax = dLen ;
         nMax = i ;
      }
      ++ i ;
      pCrv = pCompo->GetNextCurve() ;
   }
  // se non trovato o troppo corto, cerco il tratto generico più lungo
   if ( nMax < 0  ||  dLenMax < 1.25 * m_TParams.m_dDiam) {
      i = 0 ;
      pCrv = pCompo->GetFirstCurve() ;
      while ( pCrv != nullptr) {
         double dLen ;
         if ( pCrv->GetType() != CRV_LINE  &&  pCrv->GetTempProp() == 0  &&  pCrv->GetLength( dLen)  &&  dLen > dLenMax) {
            dLenMax = dLen ;
            nMax = i ;
         }
         ++ i ;
         pCrv = pCompo->GetNextCurve() ;
      }
   }

  // sposto inizio
   if ( nMax >= 0)
      pCompo->ChangeStartPoint( nMax + 0.5) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
                                    const Point3d& ptDest, bool& bSafe)
{
  // controllo dei parametri
   if ( ! ptCurr.IsValid()  ||  ! ptDest.IsValid()  ||  ! vtTool.IsValid())
      return false ;
   bSafe = true ;

  // porto ptDest alla stessa quota di ptCurr secondo vtTool
   Plane3d plProj ;
   if ( ! plProj.Set( ptCurr, vtTool))
      return false ;
   Point3d ptDestProj = ProjectPointOnPlane( ptDest, plProj) ;

  // controllo se la retta che collega ptCurr a ptDesProj è interna o esterna alla regione limite
  // devo prima creare un frame Locale XY
   if ( pSfrLimit != nullptr  &&  pSfrLimit->IsValid()) {
      PtrOwner<ISurfFlatRegion> pSfrLimitLoc( CloneSurfFlatRegion( pSfrLimit)) ;
      PtrOwner<ICurveLine> pLineLoc( CreateCurveLine()) ;
      Frame3d frLoc ;
      if ( IsNull( pSfrLimitLoc)  ||  ! frLoc.Set( ptCurr, vtTool)  ||
           ! ptDestProj.ToLoc( frLoc)  ||  ! pSfrLimitLoc->ToLoc( frLoc)  ||
           ! pSfrLimitLoc->Offset( m_TParams.m_dDiam / 2 - 10 * EPS_SMALL, ICurve::OFF_FILLET)  ||
           ! pLineLoc->Set( ORIG, ptDestProj))
         return false ;
      for ( int nC = 0 ; nC < pSfrLimitLoc->GetChunkCount()  &&  bSafe ; ++ nC) {
         CRVCVECTOR ccClass ;
         bSafe = ( pSfrLimitLoc->GetCurveClassification( *pLineLoc, EPS_SMALL, ccClass)  &&
                   int( ccClass.size()) == 1  &&  ccClass[0].nClass == CRVC_OUT) ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::VerifyLeadInHelix( const ISurfFlatRegion* pSfr, const Point3d& ptStart,
                                const Point3d& ptCen, double dHelixRad)
{
  // controllo validità dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
   Vector3d vtN = pSfr->GetNormVersor() ;
  // porto il centro sullo stesso piano del contorno
   Point3d ptCenL = ptCen - ( ptCen - ptStart) * vtN * vtN ;
  // Offset della regione
   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 - dHelixRad  + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrOffs)  ||  ! pSfrOffs->IsValid())
      return false ;
  // controllo se l'elica è valida
   bool bIsInside ;
   return ( IsPointInsideSurfFr( ptCenL, pSfrOffs, 0., bIsInside)  &&  bIsInside) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::VerifyLeadInZigZag( const ISurfFlatRegion* pSfr, const Point3d& ptStart, 
                                 const Point3d& ptPa, const Point3d& ptPb)
{
  // controllo validità dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
   Vector3d vtN = pSfr->GetNormVersor() ;
  // porto i punti sullo stesso piano del contorno
   Point3d ptPaL = ptPa - ( ptPa - ptStart) * vtN * vtN ;
   Point3d ptPbL = ptPb - ( ptPb - ptStart) * vtN * vtN ;
  // Offset della regione
   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrOffs)  ||  ! pSfrOffs->IsValid())
      return false ;
  // controllo se i due punti sono validi
   bool bIsInside ;
   return ( IsPointInsideSurfFr( ptPaL, pSfrOffs, 0., bIsInside)  &&  bIsInside  &&
            IsPointInsideSurfFr( ptPbL, pSfrOffs, 0., bIsInside)  &&  bIsInside) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, 
                                         double& dDist, Vector3d& vtNorm)
{
   if ( ! GetElevation( nPhase, ptP, vtDir, dDist, vtNorm))
      return false ;

  // se punto esterno al grezzo 
   if ( abs( dDist) < EPS_SMALL) {
      double dDist1, dDist2 ;
      if ( ! GetElevation( nPhase, ptP, -vtDir, dDist1))
         return false ;
      if ( ! GetElevation( nPhase, ptP - vtDir * ( dDist1), vtDir, dDist2, vtNorm))
         return false ;
      if ( abs( dDist2) > EPS_SMALL  &&  abs( dDist1) > EPS_SMALL)
         dDist = dDist2 - dDist1 ;
   }

  return true ;
}

// debug functions
//----------------------------------------------------------------------------
void
PocketingNT::_debug_draw_sfr( const ISurfFlatRegion* pSfr, bool bUniform)
{
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return ;

   int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSfr->Clone()) ;
   m_pGeomDB->SetMaterial( nInd, Color( 0., 255., 0., .5)) ;
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
         PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         _debug_draw_loop( pCrvCompo->Clone(), bUniform) ;
      }
   }

   return ;
}

void
PocketingNT::_debug_draw_loop( const ICurveComposite* pCrvCompo, bool bUniform)
{
   if ( pCrvCompo == nullptr  ||  ! pCrvCompo->IsValid())
      return ;

   for ( int nU = 0 ; nU < pCrvCompo->GetCurveCount() ; ++ nU) {
      int nProp0 ; pCrvCompo->GetCurveTempProp( nU, nProp0, 0) ;
      int nProp1 ; pCrvCompo->GetCurveTempProp( nU, nProp1, 1) ;
      int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( nU)->Clone()) ;
      m_pGeomDB->SetMaterial( nInd, bUniform ? WHITE : ( nProp0 == 0 ? BLUE : RED)) ;
   }

   return  ;
}