//----------------------------------------------------------------------------
//  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 "OperUserNotesConst.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 "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
#include <algorithm>

using namespace std ;

//------------------------------ Costanti ------------------------------------
static string KEY_OPEN = "OPEN" ;
static string KEY_THICK = "THICK" ;
static int LINK_CURVE_PROP = -3 ;
static double EXTRA_ELEV = 5. ;
static double EXTRA_DEPTH = 5. ;
static double SAFETY_LINK_COS = cos( - ( 175 * DEGTORAD)) ;
static double TOOL_RAD_PTSTART = 20. ;

//------------------------------ Errori/Warnings --------------------------------------
// 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"
// 2433 = "Error in PocketingNT : Calc Region Elevation failed"
// 2434 = "Error in PocketingNT : Managing Open Edges inside Raw failed"
// 2435 = "Error in PocketingNT : Managing Open Edges on Raw failed"
// 2436 = "Error in PocketingNT : not valid Raw"
// 2437 = "Error in PocketingNT : not valid Trim Surf"
// 2438 = "Error in PocketingNT : not valid Pocketing Volume"
// 2439 = "Error in PocketingNT : special apply not calculable"
// 2451 = "Warning in PocketingNT : Skipped entity (xx)"
// 2452 = "Warning in PocketingNT : No pocket"
// 2453 = "Warning in PocketingNT : Tool name changed (xx)"
// 2454 = "Warning in PocketingNT : Tool data changed (xx)"
// 2455 = "Warning in PocketingNT : No machinable pocket"
// 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)"
// 2459 = "Warning in PocketingNT : Steps too far away from Raw"

//----------------------------------------------------------------------------
// Debug
#define DEBUG_STM_TOPOLOGY 0           // Debug per topologia faccia selezionata per pStm
#define DEBUG_OPEN_EDGE_EXTENSION 0    // Debug estensione dei lati aperti
#define DEBUG_OPEN_EDGE_IN_RAW 0       // Debug gestione lati aperti interni al grezzo
#define DEBUG_SFR_STEPS 0              // Debug Sfr ( Pock e Limit) nei vari step ( risultato finale per CalcPocketing)
#define DEBUG_SFR_RAW 0                // Debug intersezioni tra SurfFlatRegion e SurfTriMesh
#define DEBUG_STM_EXTRUSION 0          // Debug superficie TriMesh di estrusione dei lati chiusi
#define DEBUG_GLIDE 0                  // Debug percorsi a Scivolo ( LeadIn/LeadOut)
#define DEBUG_MAXDEPTH 0               // Debug per controllo di MaxDepth
#define DEBUG_SAFETY_LINK 0            // Debug raccordi tra percorsi di lavorazioni differenti
#define DEBUG_FEED 0                   // Debug per Feed
#define DEBUG_START_POINT 0            // Debug per scelta del punto iniziale
#define DEBUG 0                        // Debug
#if DEBUG_STM_TOPOLOGY || DEBUG_OPEN_EDGE_EXTENSION || DEBUG_OPEN_EDGE_IN_RAW || DEBUG_SFR_STEPS || DEBUG_SFR_RAW || DEBUG_GLIDE || DEBUG_SAFETY_LINK || DEBUG_FEED || DEBUG_START_POINT || DEBUG
   #include "EgtDev/Include/EGkGeoPoint3d.h"
   #include "EgtDev/Include/EGkGeoVector3d.h"
   #include "EgtDev/Include/EGkFrame3d.h"
#endif

//----------------------------------------------------------------------------
//   USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), PocketingNT) ;

//----------------------------------------------------------------------------
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 ;
   m_bRunning = false ;
}

//----------------------------------------------------------------------------
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 ;
  // copia temporanea e reset della geometria corrente
   SELVECTOR vOldId = m_vId ;
   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
   if ( m_vId != vOldId)
      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)
{
  // se calcoli già in corso, esco
   if ( m_bRunning) {
      LOG_DBG_INFO( GetEMkLogger(), "PocketingNT::Apply already running") ;
      return true ;
   }
   m_bRunning = true ;
   bool bOk = MyApply( bRecalc, bPostApply) ;
   m_bRunning = false ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::MyApply( 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
   if ( ! UpdateToolData()) {
      m_pMchMgr->SetLastError( 2401, "Error in PocketingNT : UpdateToolData failed") ;
      return false ;
   }

  // se modificata geometria, necessario ricalcolo
   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
      bRecalc = true ;

  // verifico se necessario continuare nell'aggiornamento
   if ( ! bRecalc  &&  ( 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 ;
   }
  // altrimenti, controllo esistenza delle regioni (per compatibilità)
   else {
      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
      while ( nPathId != GDB_ID_NULL  &&  ! bChain) {
         int nGeoId = m_pGeomDB->GetFirstInGroup( nPathId) ;
         while ( nGeoId != GDB_ID_NULL  &&  ! bChain) {
            bChain = ( m_pGeomDB->GetGeoType( nGeoId) != SRF_FLATRGN) ;
            nGeoId = m_pGeomDB->GetNext( nGeoId) ;
         }
         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
      }
      if ( bChain)
         m_pGeomDB->EmptyGroup( nAuxId) ;
   }

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

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

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

   LOG_DBG_INFO( GetEMkLogger(), "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 geometria di lavorazione vuota, esco
   if ( m_nPockets == 0 ) {
      m_pMchMgr->SetWarning( 2452, "Warning in PocketingNT : No pocket") ;
      return true ;
   }
  // se lavorazione vuota, esco
   if ( ! IsAtLeastOnePathOk()) {
      m_pMchMgr->SetWarning( 2455, "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 ;
   }

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

  // se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
   if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
     // elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
      RemoveClimbRiseHome( false) ;
     // recupero i dati della testa in doppio e la imposto
      string sDblTool ; string sDblHead ; int nDblExit ;
      bool bOk = GetDoubleToolData( sDblTool, sDblHead, nDblExit)  &&
                 m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
     // imposto eventuale asse bloccato da lavorazione
      SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
     // eseguo il calcolo
      if ( bOk) {
         if ( ! CalculateDoubleAxesValues( sHint)) {
            string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
            if ( sInfo.empty())
               m_pMchMgr->SetLastError( 2423, "Error in PocketingNT : axes values not calculable for double") ;
            else
               m_pMchMgr->SetLastError( 2424, "Error in PocketingNT : double outstroke ") ;
            bOk = false ;
         }
      }
     // ripristino testa principale
      m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
     // in caso di errore, esco
      if ( ! bOk)
         return false ;
   }

  // esecuzione eventuali personalizzazioni speciali
   string sSpecErr ;
   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
      if ( ! IsEmptyOrSpaces( sSpecErr))
         m_pMchMgr->SetLastError( 2439, sSpecErr) ;
      else
         m_pMchMgr->SetLastError( 2439, "Error in PocketingNT : special apply not calculable") ;
      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 ;
   }

  // esecuzione eventuali personalizzazioni finali
   string sPostErr ;
   if ( bPostApply  &&  ! PostApply( sPostErr)) {
      if ( ! IsEmptyOrSpaces( sPostErr))
         m_pMchMgr->SetLastError( 2427, sPostErr) ;
      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( void)
{
  // 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 modificato, aggiusto lo stato
   if ( bChanged)
      m_nStatus = MCH_ST_TO_VERIFY ;
   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::AdjustCurvesByStmTopology( const ISurfTriMesh* pSurf, const Frame3d& frGlob, const ISurfTriMesh* pStmTrim,
                                        ICURVEPLIST& lstPC)
{
  // controllo dei parametri
   if ( pSurf == nullptr  ||  ! pSurf->IsValid())
      return false ;
   if ( lstPC.empty())
      return true ;
  // le curve devono essere tutte valide
   for ( auto& pCrv : lstPC) {
      if ( pCrv == nullptr  ||  ! pCrv->IsValid())
         return false ;
   }

  // trasformo la lista di curve in curve composite
   ICRVCOMPOPOVECTOR vCrvCompo ; vCrvCompo.reserve( lstPC.size()) ;
   for ( auto& pCrv : lstPC) {
      PtrOwner<ICurveComposite> pCrvCompo( ConvertCurveToComposite( pCrv->Clone())) ;
      if ( IsNull( pCrvCompo)  ||  ! pCrvCompo->IsValid()  ||
           ! vCrvCompo.emplace_back( Release( pCrvCompo)))
         return false ;
   }

  // se non ho isole e non esistono lati aperti, non faccio nulla
  // Le isole chiuse necessitano di essere estruse
   if ( int( vCrvCompo.size()) == 1) {
      bool bSomeOpen = false ;
      for ( int i = 0 ; i < vCrvCompo.back()->GetCurveCount()  &&  ! bSomeOpen ; ++ i) {
         bSomeOpen = (  vCrvCompo.back()->GetCurve( i)->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) ;
         if ( bSomeOpen)
            break ;
      }
      if ( ! bSomeOpen)
         return true ;
   }

  // controllo se esistono lati aperti interni alla superficie di Trim, in caso positivo, non faccio nulla
   const double TOL_PT_INSIDE_STM = 3. ;
   for ( auto& pCrvCompo : vCrvCompo) {
     // recupero i tratti omogenei
      ICRVCOMPOPOVECTOR vpCrvs ;
      GetHomogeneousParts( pCrvCompo, vpCrvs) ;
     // scorro i tratti alla ricerca di lati aperti
      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
         if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
           // analizzo le sottocurve del tratto
            for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j) {
              // per ogni sottocurva considero punto iniziale, finale e medio per campionarla
              // ( si potrebbe in futuro campionare in maniera più fitta )
               PNTVECTOR vPt( 3, P_INVALID) ;
               vpCrvs[i]->GetCurve( j)->GetStartPoint( vPt[0]) ;
               vpCrvs[i]->GetCurve( j)->GetMidPoint( vPt[1]) ;
               vpCrvs[i]->GetCurve( j)->GetEndPoint( vPt[2]) ;
              // classifico tali punti rispetto alla superficie
               bool bOpenEdgeInStm = false ;
               double dDist = 0. ;
               for ( int nPt = 0 ; nPt < int( vPt.size()) && ! bOpenEdgeInStm ; ++ nPt) {
                  DistPointSurfTm DistPtStm( vPt[nPt], *pStmTrim) ;
                  bOpenEdgeInStm = ( DistPtStm.IsPointInside()  &&
                                     DistPtStm.GetDist( dDist)  &&
                                     dDist > TOL_PT_INSIDE_STM) ;
               }
               if ( bOpenEdgeInStm)
                  return true ; // !!! molto restrittivo, bisogna capire cosa fare...
            }
         }
      }
   }

  // recupero il volume di svuotatura
   PtrOwner<ISurfTriMesh> pStmRawCl( CloneSurfTriMesh( pStmTrim)) ;
   PtrOwner<ISurfTriMesh> pStmVol( CloneSurfTriMesh( pStmTrim)) ;
   PtrOwner<ISurfTriMesh> pSurfGlob( CloneSurfTriMesh( pSurf)) ;
   if ( IsNull( pStmRawCl)  ||  ! pStmRawCl->IsValid()  ||
        IsNull( pStmVol)  ||  ! pStmVol->IsValid()  ||
        IsNull( pSurfGlob)  ||  ! pSurfGlob->IsValid()  ||  ! pSurfGlob->ToGlob( frGlob)  ||
        ! pStmVol->Subtract( *pSurfGlob))
      return false ;

   #if DEBUG_STM_TOPOLOGY
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "StmFaceTopology") ;
      m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
      int nStmLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nStmLay, "Stm") ;
      int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nStmLay, pSurfGlob->Clone()) ;
      m_pGeomDB->SetMaterial( nId, TEAL) ;
      int nClISlLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nClISlLay, "Closed_Isl") ;
      int nRawLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nRawLay, "Raw") ;
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pStmRawCl->Clone()) ;
      m_pGeomDB->SetMaterial( nId, PURPLE) ;
      int nVolLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nVolLay, "Vol") ;
      int nCrvLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nCrvLay, "Result") ;
   #endif

  // le isole sono considerate estese fino al grezzo; creo dei solidi di estrusione per le isole chiuse
   if ( int( vCrvCompo.size() > 1)) {
      Vector3d vtN ; lstPC.back()->GetExtrusion( vtN) ;
      const double EXTR_LEN = 1000. ;
      SurfFlatRegionByContours SfrByC ;
      for ( auto& pCrvCompo : vCrvCompo) {
         if ( ! SfrByC.AddCurve( CloneCurveComposite( pCrvCompo)))
            return false ;
      }
      PtrOwner<ISurfFlatRegion> pSfr( SfrByC.GetSurf()) ;
      if ( IsNull( pSfr)  ||  ! pSfr->IsValid())
         return false ;
      for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
         for ( int nL = 1 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
            bool bClosedIsl = true ;
            int nTmpProp = TEMP_PROP_INVALID ;
            for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) && bClosedIsl ; ++ nU)
               bClosedIsl = ( pSfr->GetCurveTempProp( nC, nL, nU, nTmpProp, 0) && nTmpProp == TEMP_PROP_CLOSE_EDGE) ;
            if ( bClosedIsl) {
               PtrOwner<ICurve> pCrvLoop( pSfr->GetLoop( nC, nL)) ;
               if ( ! IsNull( pCrvLoop)  &&  pCrvLoop->IsValid()) {
                  pCrvLoop->Translate( - EXTR_LEN / 2. * vtN) ;
                  pCrvLoop->SetExtrusion( vtN) ;
                  OffsetCurve OffsCrv ;
                  if ( ! OffsCrv.Make( pCrvLoop, 10 * EPS_SMALL, ICurve::OFF_FILLET)  ||
                       ! pCrvLoop.Set( OffsCrv.GetLongerCurve()))
                     return false ;
                  PtrOwner<ISurfTriMesh> pStmExtr( GetSurfTriMeshByExtrusion( pCrvLoop, EXTR_LEN * vtN, true)) ;
                  if ( ! IsNull( pStmExtr)  &&  pStmExtr->IsValid()  &&  pStmExtr->IsClosed()) {
                     double dVol = 0. ;
                     if ( pStmExtr->GetVolume( dVol)  &&  dVol < 0.)
                        pStmExtr->Invert() ;
                     #if DEBUG_STM_TOPOLOGY
                        int nIslId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nClISlLay, CloneSurfTriMesh( pStmExtr)) ;
                        m_pGeomDB->SetMaterial( nIslId, BLACK) ;
                     #endif
                     if ( ! pStmVol->Subtract( *pStmExtr))
                        return false ;
                  }
               }
            }
         }
      }
   }

   #if DEBUG_STM_TOPOLOGY
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pStmVol->Clone()) ;
      m_pGeomDB->SetMaterial( nId, GREEN) ;
   #endif

  // se volume non chiuso, errore
   if ( ! pStmVol->IsClosed())
      return false ;

  // se il volume è composto da più parti, scelgo quella inerente alla superficie TriMesh selezionata
   if ( pStmVol->GetPartCount() > 1) {
     // Box della TriMesh da lavorare
      BBox3d BBoxPock ; pSurfGlob->GetLocalBBox( BBoxPock) ;
      BBoxPock.Expand( 50. * EPS_SMALL) ; // euristica
      for ( int nP = 0 ; nP < pStmVol->GetPartCount() ; ++ nP) {
        // Box della parte
         BBox3d BBoxPart ; pStmVol->GetPartLocalBBox( nP, BBoxPart) ;
         BBoxPart.Expand( 50. * EPS_SMALL) ; // euristica
         BBox3d BBoxInt ;
         if ( ! BBoxPart.FindIntersection( BBoxPock, BBoxInt)  ||  BBoxInt.IsEmpty()) {
            pStmVol->RemovePart( nP) ;
            -- nP ;
         }
      }
   }

  // proeitto la superficie ricavata e il grezzo sul piano intrinseco della regione piana
   Vector3d vtN ; lstPC.back()->GetExtrusion( vtN) ;
   Point3d ptC ; lstPC.back()->GetCentroid( ptC) ;
   Plane3d plProj ;
   if ( ! plProj.Set( ptC, vtN))
      return false ;
   POLYLINEVECTOR vPLVol, vPLRaw ;
   if ( ! pStmVol->GetSilhouette( plProj, 20 * EPS_SMALL, vPLVol))
      return false ;
   if ( ! pStmRawCl->GetSilhouette( plProj, 20 * EPS_SMALL, vPLRaw))
      return false ;

   #if DEBUG_STM_TOPOLOGY
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pStmRawCl->Clone()) ;
      m_pGeomDB->SetMaterial( nId, BLUE) ;
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pStmVol->Clone()) ;
      m_pGeomDB->SetMaterial( nId, LIME) ;
   #endif

  // recupero le due superfici piane
   SurfFlatRegionByContours SfrBCVol, SfrBCRaw ;
   for ( PolyLine& PL : vPLVol) {
      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
      if ( ! IsNull( pCompo)  &&  pCompo->FromPolyLine( PL))
         SfrBCVol.AddCurve( Release( pCompo)) ;
   }
   for ( PolyLine& PL : vPLRaw) {
      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
      if ( ! IsNull( pCompo)  &&  pCompo->FromPolyLine( PL))
         SfrBCRaw.AddCurve( Release( pCompo)) ;
   }
   PtrOwner<ISurfFlatRegion> pSfrVol( SfrBCVol.GetSurf()) ;
   PtrOwner<ISurfFlatRegion> pSfrRaw( SfrBCRaw.GetSurf()) ;
   if ( IsNull( pSfrVol)  ||  IsNull( pSfrRaw)  ||
        ! pSfrVol->IsValid()  ||  ! pSfrRaw->IsValid())
      return false ;
   if ( AreOppositeVectorApprox( vtN, pSfrVol->GetNormVersor()))
      pSfrVol->Invert() ;
   if ( AreOppositeVectorApprox( vtN, pSfrRaw->GetNormVersor()))
      pSfrRaw->Invert() ;

   #if DEBUG_STM_TOPOLOGY
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawLay, pSfrRaw->Clone()) ;
      m_pGeomDB->SetMaterial( nId, BLUE) ;
      nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nVolLay, pSfrVol->Clone()) ;
      m_pGeomDB->SetMaterial( nId, LIME) ;
   #endif

  // se la nuova superficie ricavata contiene un tratto chiuso, allora non faccio nulla
  // ( Esempio di una tasca inclinata con gradini )
   const double OFFSET_FOR_CLOSE = 1. ;  // euristico
   PtrOwner<ISurfFlatRegion> pSfrVol_Clone( pSfrVol->CreateOffsetSurf( - OFFSET_FOR_CLOSE, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrVol_Clone))
      return false ;
   for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
      ICRVCOMPOPOVECTOR vpCrvs ;
      GetHomogeneousParts( vCrvCompo[i], vpCrvs) ;
      for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
         if ( vpCrvs[j]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
            CRVCVECTOR ccClass ;
            if ( pSfrVol_Clone->GetCurveClassification( *vpCrvs[j], EPS_SMALL, ccClass)) {
               for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) {
                  if ( ccClass[k].nClass != CRVC_OUT) {
                    // non estendo la superficie in quanto rovina il grezzo adiacente ad un chiuso
                     return true ;
                  }
               }
            }
            else
               return false ;
         }
      }
   }

  // definisco i lati aperti della nuova regione da svuotare
  // --- i lati aperti sono quelli in comune con la proiezione del grezzo
   for ( auto& pCrv : lstPC)
      delete( pCrv) ;
   lstPC.clear() ;
   pSfrRaw->Offset( - 50 * EPS_SMALL, ICurve::OFF_FILLET) ;
   for ( int nC = 0 ; nC < pSfrVol->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfrVol->GetLoopCount( nC) ; ++ nL) {
        // recupero il Loop
         PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfrVol->GetLoop( nC, nL))) ;
         if ( IsNull( pCompoLoop)  ||  ! pCompoLoop->IsValid())
            return false ;
         for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
            PNTVECTOR vPt( 3, P_INVALID) ;
            pCompoLoop->GetCurve( nU)->GetStartPoint( vPt[0]) ;
            pCompoLoop->GetCurve( nU)->GetMidPoint( vPt[1]) ;
            pCompoLoop->GetCurve( nU)->GetEndPoint( vPt[2]) ;
            pCompoLoop->SetCurveTempProp( nU, TEMP_PROP_OPEN_EDGE, 0) ;
            for ( int nPt = 0 ; nPt < int( vPt.size()) ; ++ nPt) {
               bool bIsInside = true ;
               IsPointInsideSurfFr( vPt[nPt], pSfrRaw, EPS_SMALL, bIsInside) ;
               if ( bIsInside) {
                  pCompoLoop->SetCurveTempProp( nU, TEMP_PROP_CLOSE_EDGE, 0) ;
                  break ;
               }
            }
         }

         #if DEBUG_STM_TOPOLOGY
            for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
               int nProp0 ; pCompoLoop->GetCurveTempProp( nU, nProp0, 0) ;
               int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nCrvLay, pCompoLoop->GetCurve( nU)->Clone()) ;
               m_pGeomDB->SetMaterial( nInd, ( nProp0 == 0 ? BLUE : RED)) ;
            }
         #endif

         lstPC.emplace_back( Release( pCompoLoop)) ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GetCurves( const SelData& Id, const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmTrim, 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 ;
      Vector3d vtExtr ;
      // 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
         if ( ! pCurve->GetExtrusion( vtExtr)  ||  vtExtr.IsSmall())
            pCurve->SetExtrusion( Z_AX) ;
        // sistemo senso antiorario visto dalla direzione di estrusione
         Plane3d plPlane ; double dArea ;
         pOriCurve->GetArea( plPlane, dArea) ;
         if ( plPlane.GetVersN() * vtExtr * dArea < 0)
            pCurve->Invert() ;
      }
      // 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
         if ( ! pCompo->GetExtrusion( vtExtr)  ||  vtExtr.IsSmall())
            vtExtr = Z_AX ;
         pCurve->SetExtrusion( vtExtr) ;
         double dThick ;
         if ( pCompo->GetThickness( dThick))
            pCurve->SetThickness( dThick) ;
        // sistemo senso antiorario visto dalla direzione di estrusione
         Plane3d plPlane ; double dArea ;
         pCompo->GetArea( plPlane, dArea) ;
         if ( plPlane.GetVersN() * vtExtr * dArea < 0)
            pCurve->Invert() ;
      }
      if ( IsNull( pCurve))
         return false ;
     // la porto in globale
      pCurve->ToGlob( frGlob) ;
     // la restituisco
      lstPC.emplace_back( Release( pCurve)) ;
      return true ;
   }

  // --- se 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 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
      ICURVEPLIST lstCrvLoops ;
      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, TEMP_PROP_OPEN_EDGE) ;
           // 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, TEMP_PROP_OPEN_EDGE) ;
            }
           // 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
         if ( m_bAllClose)
            ResetCurveAllTempProp( pCrvCompo) ;
         lstCrvLoops.emplace_back( Release( pCrvCompo)) ;
      }
     // aggiusto la topologia della faccia
      AdjustCurvesByStmTopology( pSurf, frGlob, ( pStmTrim == nullptr ? pStmRaw : pStmTrim), lstCrvLoops) ;
      for ( auto& pCrv : lstCrvLoops)
         lstPC.emplace_back( pCrv) ;
      return true ;
   }

  // --- se regione piana
   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 ;

   return true ;
}

//----------------------------------------------------------------------------
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) ;
   if ( m_bAllClose)
      return true ;
  // 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 proprietà 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, TEMP_PROP_CLOSE_EDGE) ;
   }
   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 ;
  // flag per imposizione lati chiusi
   m_bAllClose = GetForcedClosed() ;

  // recupero il grezzo in globale
   PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
   if ( IsNull( pStmRaw)  ||  ! pStmRaw->IsValid()  ||  pStmRaw->GetTriangleCount() == 0) {
      m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
      return false ;
   }

  // recupero la superficie di Trim in globale [nullptr se non presente]
   PtrOwner<ISurfTriMesh> pStmTrim( GetStmTrim()) ;

  // recupero tutte le curve e le porto in globale
   for ( const auto& Id : m_vId) {
     // prendo le curve
      ICURVEPLIST lstPC ;
      if ( ! GetCurves( Id, pStmRaw, pStmTrim, 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
   ICRVCOMPOPOVECTOR vCrvCompo ;
   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
      vCrvCompo.emplace_back( Release( pCrvCompo)) ;
     // salvo vettore estrusione
      vCrvCompo.back()->SetExtrusion( vtExtr) ;
     // salvo la thickness come seconda temp prop ( la Sfr rimuove la thick delle curve)
      vCrvCompo.back()->SetTempParam( dThick, 1) ;
   }

  // ordino le curve creando una regione piana
   SurfFlatRegionByContours SfrByC ;
   for ( int i = 0 ; i < int( vCrvCompo.size()) ; ++ i) {
     // memorizzo la Thickness nei TempParams
      vCrvCompo[i]->SetTempParam( vCrvCompo[i]->GetTempParam( 1), 1) ;
      SfrByC.AddCurve( Release( vCrvCompo[i])) ;
   }

  // 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 ;
        // recupero la ThickNess e l'Estrusione dal Loop esterno
         PtrOwner<ICurveComposite> pCrvInfo( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, 0))) ;
         if ( IsNull( pCrvInfo)  ||  ! pCrvInfo->IsValid())
            return false ;
         double dThick = pCrvInfo->GetTempParam( 1) ;
         Vector3d vtExtr ; pCrvInfo->GetExtrusion( vtExtr) ;
        // -------------- Verifico quale part del Grezzo bisogna considerare ----------------
         if ( ! ChooseRawPart( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
            m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
            return false ;
         }
        // -------------- Controllo esistenza di lati aperti interni al grezzo --------------
        // Questi lati vengono Offsettati, raccordati e considerati poi come chiusi
         if ( ! ManageOpenEdges( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
            m_pMchMgr->SetLastError( 2434, "Error in PocketingNT : Managing Open Edges inside Part failed") ;
            return false ;
         }
        // ------------- Estendo i lati aperti sul bordo per possibili proiezioni -------------
         if ( ! ExtendOpenEdges( pSfrChunk, ( pStmTrim == nullptr ? pStmRaw : pStmTrim))) {
            m_pMchMgr->SetLastError( 2435, "Error in PocketingNT : Managing Open Edges on Raw failed") ;
            return false ;
         }
        // scorro i suoi Loop
         int nNewId = GDB_ID_NULL ;
         for ( int nL = 0 ; nL < pSfrChunk->GetLoopCount( 0) ; ++ nL) {
           // recupero il Loop
            PtrOwner<ICurveComposite> pCrvLoop( CreateCurveComposite()) ;
            if ( IsNull( pCrvLoop)  ||
                 ! pCrvLoop.Set( ConvertCurveToComposite( pSfrChunk->GetLoop( 0, nL)))  ||
                 !  pCrvLoop->IsValid())
               return false ;
           // se loop esterno, aggiungo la superfifice al gruppo con le relative informazioni
            if ( nL == 0) {
               nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::CloneSurfFlatRegion( pSfrChunk)) ;
               if ( nNewId == GDB_ID_NULL)
                  return false ;
               m_pGeomDB->SetInfo( nNewId, KEY_THICK, dThick) ;
               m_pGeomDB->SetInfo( nNewId, KEY_EXTR, vtExtr) ;
            }
           // 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) ;
         }
      }
     // 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::GetStmTrim( void)
{
  // controllo se è presente una superficie di Trim
   int nStmTrimId = GDB_ID_NULL ;
   if ( ! GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nStmTrimId))
      return nullptr ;

  // creo Stm della superficie di Trim
   PtrOwner<ISurfTriMesh> pStmTrim( CreateSurfTriMesh()) ;
   if ( IsNull( pStmTrim))
      return nullptr ;
   pStmTrim->AdjustTopology() ;

  // recupero l'oggetto geometrico
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nStmTrimId) ;
   if ( pGObj == nullptr)
      return nullptr ;

  // controllo che sia una superficie TriMesh
   if ( pGObj->GetType() != SRF_TRIMESH)
      return nullptr ;

  // ne recupero il riferimento globale
   Frame3d frGlob ;
   if ( ! m_pGeomDB->GetGlobFrame( nStmTrimId, frGlob))
      return nullptr ;

  // recupero la TriMesh di Trim
   SurfLocal StmRawPart( GetSurfTriMesh( pGObj), frGlob, GLOB_FRM) ;
   pStmTrim->Add( *GetSurfTriMesh( StmRawPart)) ;
   return ( ( pStmTrim->IsValid()  &&  pStmTrim->GetTriangleCount() > 0) ? Release( pStmTrim) : nullptr) ;
}

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

  /*
      pSfr -> superficie da cui estrudere i lati chiusi
      vtExtrs -> vettore estrusione dei lati chiusi di pSfr
  */

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

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

  // scorro i Loop della superficie piana
   bool bExistClose = false ;
   for ( int nC = 0 ; nC < pMySfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pMySfr->GetLoopCount( nC) ; ++ nL) {
        // recupero il Loop come curva composita
         PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pMySfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCompoLoop)  ||  !  pCompoLoop->IsValid())
            return nullptr ;
        // recupero i tratti con proprietà uniformi
         ICRVCOMPOPOVECTOR vpCrvs ;
         if ( ! GetHomogeneousParts( pCompoLoop, vpCrvs))
            return nullptr ;
        // 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) ;
}

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

  // recupero il piano di taglio dalla regione piana
   Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
   Plane3d plProj ;
   if ( ! plProj.Set( ptCen, vtTool))
      return nullptr ;

  // recupero la Silhouette al piano trovato
   POLYLINEVECTOR vPL ;
   if ( ! pStmRaw->GetSilhouette( plProj, EPS_SMALL, vPL))
      return nullptr ;
  // se non trovo nessun contorno sono fuori dal grezzo, la superficie è vuota
   if ( vPL.empty())
      return ( CreateSurfFlatRegion()) ;

  // costruisco la regione piana
   SurfFlatRegionByContours SfrByC ;
   for ( const PolyLine& PL : vPL) {
      PtrOwner<ICurveComposite> pCrvLoop( CreateCurveComposite()) ;
      if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->FromPolyLine( PL))
         return nullptr ;
      SfrByC.AddCurve( Release( pCrvLoop)) ;
   }
   PtrOwner<ISurfFlatRegion> pSfrRaw( SfrByC.GetSurf()) ;
   if ( IsNull( pSfrRaw)  ||  ! pSfrRaw->IsValid())
      return nullptr ;
   if ( AreOppositeVectorApprox( pSfrRaw->GetNormVersor(), vtTool))
      pSfrRaw->Invert() ;
   return Release( pSfrRaw) ;
}

//----------------------------------------------------------------------------
Point3d
PocketingNT::GetStartPointsByHead( const STEPINFOPOVECTOR& vStepInfo) const
{
  // se non ho step, allora non ho un punto di riferimento
   if ( vStepInfo.empty())
      return P_INVALID ;

  // sull'ultimo Step ( quindi sulla geometria più simile a quella originaria) cerco il tratto aperto più lungo
  // ( inteso come media tra gli aperti sui Chunks)
  // recupero la prima regione valida a partire dalla più profonda
   auto it = vStepInfo.rbegin() ;
   for ( ; it != vStepInfo.rend() ; ++ it) {
      if ( ( *it).pSfrPock != nullptr  &&  ( *it).pSfrPock->IsValid()  &&
           ( *it).pSfrPock->GetChunkCount() > 0)
         break ;
   }
  // recupero la regione
   const ISurfFlatRegion* pSfr = ( *it).pSfrPock ;
   if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||  pSfr->GetChunkCount() == 0)
      return P_INVALID ;
   #if DEBUG_START_POINT // rimuovi "const" nella dichiarazione della funzione
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "Start_Point") ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      DebugDrawSfr( pSfr, false, nLay) ;
   #endif
  // se la normale della regione è circa Z+ o Z- non devo fare nulla
   if ( AreSameOrOppositeVectorApprox( pSfr->GetNormVersor(), Z_AX))
      return P_INVALID ;

  // dichiaro il nuovo punto per la possibile entrata
   double dZGlob = ( m_bAboveHead ? - INFINITO : INFINITO) ;
   Point3d ptRef = P_INVALID ;

  // controllo se sono presenti dei lati aperti
   vector<tuple<int, int, int, double, double>> vIndCrv ;
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
        // recupero il Loop
         PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCompoLoop)  ||  ! pCompoLoop->IsValid())
            return P_INVALID ;
        // scorro le sue curve
         for ( int nU = 0 ; nU < pCompoLoop->GetCurveCount() ; ++ nU) {
            const ICurve* pCrv = pCompoLoop->GetCurve( nU) ;
            if ( pCrv == nullptr  ||  ! pCrv->IsValid())
               return P_INVALID ;
            if ( pCrv->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
              // calcolo il Box globale della curva e memorizzo la componente Z ( media)
               BBox3d BBoxGlob ;
               if ( pCrv->GetLocalBBox( BBoxGlob)) {
                 // se testa da sopra
                  if ( m_bAboveHead) {
                     if ( BBoxGlob.GetMax().z > dZGlob + 10. * EPS_SMALL) {
                        dZGlob = BBoxGlob.GetMax().z ;
                        vIndCrv.clear() ;
                        vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
                     }
                     else if ( BBoxGlob.GetMax().z > dZGlob - 10. * EPS_SMALL)
                        vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
                  }
                 // se testa da sotto
                  else {
                     if ( BBoxGlob.GetMin().z < dZGlob - 10. * EPS_SMALL) {
                        dZGlob = BBoxGlob.GetMin().z ;
                        vIndCrv.clear() ;
                        vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
                     }
                     else if ( BBoxGlob.GetMin().z < dZGlob + 10. * EPS_SMALL)
                        vIndCrv.emplace_back( make_tuple( nC, nL, nU, BBoxGlob.GetMin().z, BBoxGlob.GetMax().z)) ;
                  }
               }
            }
         }
      }
   }
   #if DEBUG_START_POINT
      for ( int _i = 0 ; _i < ssize( vIndCrv) ; ++ _i) {
         const ICurveComposite* _pCompo = ConvertCurveToComposite( pSfr->GetLoop( get<0>( vIndCrv[_i]), get<1>( vIndCrv[_i]))) ;
         const ICurve* _pCurve = _pCompo->GetCurve( get<2>( vIndCrv[_i])) ;
         int _nCrv = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, _pCurve->Clone()) ;
         m_pGeomDB->SetMaterial( _nCrv, YELLOW) ;
      }
   #endif
  // se non ho candidate, non ho un punto di riferimento
   if ( vIndCrv.empty())
      return P_INVALID ;
   int nChunk = 0, nLoop = 0, nCurve = 0 ;
  // se una sola candidata allora il punto è quello
   if ( ssize( vIndCrv) == 1) {
      nChunk = get<0>( vIndCrv[0]) ;
      nLoop = get<1>( vIndCrv[0]) ;
      nCurve = get<2>( vIndCrv[0]) ;
   }
   else {
      int nIndTuple = 0 ;
      double dZMin = - INFINITO, dZMax = + INFINITO ;
      for ( int i = 0 ; i < ssize( vIndCrv) ; ++ i) {
        // se testa da sopra
         if ( m_bAboveHead) {
           // scelgo la curva con Zmin massima
            if ( get<3>( vIndCrv[i]) > dZMin) {
               dZMin = get<3>( vIndCrv[i]) ;
               nIndTuple = i ;
            }
         }
        // se testa da sotto
         else {
           // scelgo la curva con ZMax minima
            if ( get<4>( vIndCrv[i]) < dZMax) {
               dZMax = get<4>( vIndCrv[i]) ;
               nIndTuple = i ;
            }
         }
      }
      nChunk = get<0>( vIndCrv[nIndTuple]) ;
      nLoop = get<1>( vIndCrv[nIndTuple]) ;
      nCurve = get<2>( vIndCrv[nIndTuple]) ;
   }

  // Verifico se effettivamente l'utensile può entrare da quella sottocurva
   PtrOwner<ICurveComposite> pCompoLoop( ConvertCurveToComposite( pSfr->GetLoop( nChunk, nLoop))) ;
   if ( pCompoLoop == nullptr  ||  ! pCompoLoop->IsValid())
      return P_INVALID ;
   const ICurve* pCurveRef = pCompoLoop->GetCurve( nCurve) ;
   if ( pCurveRef == nullptr  ||  ! pCurveRef->IsValid())
      return P_INVALID ;
  // il punto di riferimento per ora è il punto medio ( se i lati aperti sono segmenti va bene...)
   pCurveRef->GetMidPoint( ptRef) ;
   #if DEBUG_START_POINT
      IGeoPoint3d* _ptRef = CreateGeoPoint3d() ; _ptRef->Set( ptRef) ;
      m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, _ptRef) ;
      m_pGeomDB->SetMaterial( nLay, YELLOW) ;
   #endif
   double dToTLen = 0 ;
   pCurveRef->GetLength( dToTLen) ;
   if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
      return ptRef ;
  // verifico se i tratti adiacenti permettono comunque una possibile entrata
   int nToTCurves = pCompoLoop->GetCurveCount() ;
   if ( nToTCurves == 1)
      return ptRef ;
   else {
      const ICurve* pCurvePrev = pCompoLoop->GetCurve( ( nCurve - 1 + nToTCurves) % nToTCurves) ;
      if ( pCurvePrev != nullptr  &&  pCurvePrev->IsValid()  &&  pCurvePrev->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
         double dLenPrev ; pCurvePrev->GetLength( dLenPrev) ;
         Vector3d vtPrevEnd ; pCurvePrev->GetEndDir( vtPrevEnd) ;
         Vector3d vtStart ; pCurveRef->GetStartDir( vtStart) ;
         dToTLen += max( 0.4, vtPrevEnd * vtStart) * dLenPrev ;
      }
      if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
         return ptRef ;
      if ( nToTCurves > 2) {
         const ICurve* pCurveNext = pCompoLoop->GetCurve( ( nCurve + 1 + nToTCurves) % nToTCurves) ;
         if ( pCurveNext != nullptr  &&  pCurveNext->IsValid()  &&
              pCurveNext->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
            double dLenNext ; pCurveNext->GetLength( dLenNext) ;
            Vector3d vtEnd ; pCurveRef->GetEndDir( vtEnd) ;
            Vector3d vtNextStart ; pCurveNext->GetStartDir( vtNextStart) ;
            dToTLen += max( 0.4, vtEnd * vtNextStart) * dLenNext ;
         }
         if ( dToTLen > m_TParams.m_dDiam + GetOffsR())
            return ptRef ;
      }
   }

  // potrei cercarne un altro... se serve migliorare...
   return P_INVALID ;
}

//----------------------------------------------------------------------------
Point3d
PocketingNT::GetStartPointsFromSteps( const STEPINFOPOVECTOR& vStepInfo, int nCrvType) const
{
  // se non ho step, allora non ho un punto di riferimento
   if ( vStepInfo.empty())
      return P_INVALID ;

  // sull'ultimo Step ( quindi sulla geometria più simile a quella originaria) cerco il tratto aperto più lungo
  // ( inteso come media tra gli aperti sui Chunks)
  // recupero la prima regione valida a partire dalla più profonda
   auto it = vStepInfo.rbegin() ;
   for ( ; it != vStepInfo.rend() ; ++ it) {
      if ( ( *it).pSfrPock != nullptr  &&  ( *it).pSfrPock->IsValid()  &&
           ( *it).pSfrPock->GetChunkCount() > 0)
         break ;
   }
  // recupero la regione
   const ISurfFlatRegion* pSfr = ( *it).pSfrPock ;
   if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||  pSfr->GetChunkCount() == 0)
      return P_INVALID ;
   #if DEBUG_START_POINT // rimuovi "const" nella dichiarazione della funzione
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "Start_Point") ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      DebugDrawSfr( pSfr, false, nLay) ;
   #endif

  // scorro le curve
   PNTVECTOR vPnts ;
   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> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
            continue ;
        // recupero i tratti con proprietà uniformi
         ICRVCOMPOPOVECTOR vpCrvs ;
         GetHomogeneousParts( pCrvLoop, vpCrvs) ;
         double dLenRef = 0. ;
         int nIndRef = -1, nCrvRef = -1 ;
         Point3d ptMid ;
        // se bordo tutto aperto, allora cerco il punto medio della curva più lunga
         if ( int( vpCrvs.size()) == 1  &&  vpCrvs[0]->GetTempProp() == TEMP_PROP_OPEN_EDGE) {
            for ( int nU = 0 ; nU < vpCrvs[0]->GetCurveCount() ; ++ nU) {
               double dLen = 0. ; vpCrvs[0]->GetCurve( nU)->GetLength( dLen) ;
               if ( dLen > dLenRef) {
                  dLenRef = dLen ;
                  nIndRef = nU ;
               }
            }
            if ( nIndRef == -1)
               continue ;
            vpCrvs[0]->GetCurve( nIndRef)->GetMidPoint( ptMid) ;
         }
         else {
           // scorro i tratti con le proprietà richieste e cerco quello più lungo
            for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
               if ( vpCrvs[i]->GetTempProp() == nCrvType) {
                 // scorro le curve che lo compongono
                  for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
                    // recupero la curva corrente
                     const ICurve* pCrv = vpCrvs[i]->GetCurve( j) ;
                     if ( pCrv != nullptr  &&  pCrv->IsValid()) {
                        double dLen = 0. ; vpCrvs[i]->GetLength( dLen) ;
                        if ( dLen > dLenRef) {
                           dLenRef = dLen ;
                           nIndRef = i ;
                           nCrvRef = j ;
                        }
                     }
                  }
               }
            }
            if ( nIndRef == -1  ||  nCrvRef == -1)
               continue ;
            vpCrvs[nIndRef]->GetCurve(nCrvRef)->GetMidPoint( ptMid) ;
         }

         #if DEBUG_START_POINT
            PtrOwner<IGeoPoint3d> myPtMid( CreateGeoPoint3d()) ;
            myPtMid->Set( ptMid) ;
            int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPtMid->Clone()) ;
            m_pGeomDB->SetMaterial( nId, nCrvType == TEMP_PROP_CLOSE_EDGE ? AQUA : ORANGE) ;
         #endif
         vPnts.emplace_back( ptMid) ;
      }
   }
  // se non ho punti allora esco
   if ( vPnts.empty())
      return P_INVALID ;
  // recupero il punto medio
   double dX = 0., dY = 0., dZ = 0. ;
   for ( const Point3d& myPt : vPnts) {
      dX += myPt.x ;
      dY += myPt.y ;
      dZ += myPt.z ;
   }
   Point3d ptStart = Point3d( dX / int( vPnts.size()),
                              dY / int( vPnts.size()),
                              dZ / int( vPnts.size())) ;
  // proietto il punto sul primo step
   ptStart.Translate( ( - ( *it).dDepth + vStepInfo.front().dDepth) * ( *it).pSfrPock->GetNormVersor()) ;
   #if DEBUG_START_POINT
      PtrOwner<IGeoPoint3d> myPtStart( CreateGeoPoint3d()) ;
      myPtStart->Set( ptStart) ;
      int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, myPtStart->Clone()) ;
      m_pGeomDB->SetMaterial( nId, YELLOW) ;
   #endif

   return ptStart ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const
{
  // controllo dei parametri
   if ( pCrvCompo == nullptr  ||  ! pCrvCompo->IsValid())
      return false ;
   vpCrvs.clear() ;

  // scorro tutte le curve semplici nella composita
   int nCurrTempProp ;
   int nParStart = 0 ;
   for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++ i) {
     // ricavo la TmpProp
      int nTempProp ;
      pCrvCompo->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( pCrvCompo->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( pCrvCompo->CopyParamRange( nParStart, pCrvCompo->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) ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
{
  /* I lati aperti vengono estesi (mediante proiezione del box di pStm tagliata da un piano definito
  *  da pSfr) in modo da estendere la regione di lavoro */

  // controllo dei parametri
   if ( pSfr == nullptr  ||  pStm == nullptr)
      return false ;
   if ( ! pSfr->IsValid())
      return true ;

  // Se non richiesto controllo con il Grezzo, non estendo alcun lato
  // ( NB. potrebbe essere scelto un unteriore parametro dalle note utenti)
   int nOpenOutRaw ;
   m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw)  &&  nOpenOutRaw != 0) ;
   if ( m_bOpenOutRaw)
      return true ;

  // se la superficie non ha lati aperti, allora non devo fare nulla
   bool bAllClosed = true ;
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() && bAllClosed ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) && bAllClosed ; ++ nL) {
         for ( int nU = 0 ; nU < pSfr->GetLoopCurveCount( nC, nL) && bAllClosed ; ++ nU) {
            int nTmpProp = TEMP_PROP_INVALID ;
            bAllClosed = ( pSfr->GetCurveTempProp( nC, nL, nU, nTmpProp, 0)  &&
                           nTmpProp == TEMP_PROP_CLOSE_EDGE) ;
         }
      }
   }
   if ( bAllClosed)
      return true ;

  // recupero i Chunk della superficie
   ISURFFRPOVECTOR vChunks( pSfr->GetChunkCount()) ;
   for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC)
      vChunks[nC].Set( pSfr->CloneChunk( nC)) ;

   #if DEBUG_OPEN_EDGE_EXTENSION
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLay, "Open_edge_extension") ;
      DebugDrawSfr( pSfr, false, nLay) ;
   #endif
  // clono la superficie trimesh ( devo effettuare un taglio)
   PtrOwner<ISurfTriMesh> pStmCL( CloneSurfTriMesh( pStm)) ;
   if ( IsNull( pStmCL)  ||  ! pStmCL->IsValid()  ||  pStmCL->GetTriangleCount() == 0)
      return false ;
  // definisco un piano di taglio per il grezzo, mediante la curva
   Plane3d plCut ;
   Point3d ptC ; pSfr->GetCentroid( ptC) ;
   if ( ! plCut.Set( ptC, - pSfr->GetNormVersor()))
      return false ;
  // taglio il grezzo con il piano
   if ( ! pStmCL->Cut( plCut, true))
      return false ;
   if ( ! pStmCL->IsValid()  ||  pStmCL->GetTriangleCount() == 0)
      return true ;
   #if DEBUG_OPEN_EDGE_EXTENSION
      int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pStmCL->Clone()) ;
      m_pGeomDB->SetMaterial( a, Color( 0.2, 0.2, 0.8, .65)) ;
   #endif
  // recupero il Box del grezzo definito dal frame implicito dal piano
   Frame3d frCut ;
   if ( ! frCut.Set( ptC, pSfr->GetNormVersor()))
      return false ;
   frCut.Invert() ;
   BBox3d BBoxRawCut ;
   if ( ! pStmCL->GetBBox( frCut, BBoxRawCut))
      return false ;
   #if DEBUG_OPEN_EDGE_EXTENSION
      frCut.Invert() ;
      DebugDrawBox( BBoxRawCut, frCut, nLay) ;
      frCut.Invert() ;
   #endif

  // scorro i Chunk della superficie
   bool bModifSfr = false ;
   for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC) {
     // recupero il Loop esterno ( per ora non considero le isole)
      PtrOwner<ICurveComposite> pCrvExtLoop( ConvertCurveToComposite( vChunks[nC]->GetLoop( 0, 0))) ;
      if ( IsNull( pCrvExtLoop)  ||  ! pCrvExtLoop->IsValid())
         return false ;
     // recupero i tratti con proprietà uniformi della superficie
      ICRVCOMPOPOVECTOR vpCrvs ;
      if ( ! GetHomogeneousParts( pCrvExtLoop, vpCrvs))
         return false ;
     // se il bordo è tutto chiuso, allora passo al prossimo Chunk
      if ( int( vpCrvs.size()) == 1  &&  vpCrvs[0]->GetTempProp() == TEMP_PROP_CLOSE_EDGE)
         continue ;
     // definisco la nuova curva di bordo
      PtrOwner<ICurveComposite> pCrvNewBorder( CreateCurveComposite()) ;
      if ( IsNull( pCrvNewBorder))
         return false ;
     // definisco offset di estensione per tratti aperti
      double dMaxDimBox = max( BBoxRawCut.GetDimX(), BBoxRawCut.GetDimY()) ;
      double dOffs = min( 3. * m_TParams.m_dDiam, dMaxDimBox) + m_TParams.m_dDiam ;
      double dOffsUser = 0. ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_PROJEXT, dOffsUser)  && dOffsUser > EPS_SMALL)
         dOffs = dOffsUser ;
     // sostiuisco ogni tratto aperto con il suo Offset
      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
         if ( vpCrvs[i]->GetTempProp() == TEMP_PROP_OPEN_EDGE) {
            vpCrvs[i]->SetExtrusion( pSfr->GetNormVersor()) ;
            OffsetCurve OffsCurve ;
            OffsCurve.Make( vpCrvs[i], dOffs, ICurve::OFF_EXTEND) ;
            PtrOwner<ICurveComposite> pCompoOpenOffs( ConvertCurveToComposite( OffsCurve.GetLongerCurve())) ;
            if ( ! IsNull( pCompoOpenOffs)  &&  pCompoOpenOffs->IsValid()) {
               for ( int j = 0 ; j < pCompoOpenOffs->GetCurveCount() ; ++ j)
                  pCompoOpenOffs->SetCurveTempProp( j, TEMP_PROP_OPEN_EDGE, 0) ;
               pCompoOpenOffs->SetTempProp( TEMP_PROP_OPEN_EDGE, 0) ;
               vpCrvs[i].Set( Release( pCompoOpenOffs)) ;
            }
         }
      }
     // caso limite : tutta la curva è aperta
      if ( int( vpCrvs.size()) == 1  &&  vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE)
         pCrvNewBorder.Set( Release( vpCrvs[0])) ;
      else {
        // scorro i tratti omogenei
         Point3d ptLineS, ptLineE ;
         for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
            if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
              // recupero l'indice del tratto chiuso precedente e successivo
               int nIndCLprec = ( i == 0 ? int( vpCrvs.size()) -1 : i - 1) ;
               int nIndCLsucc = ( i == int( vpCrvs.size()) -1 ? 0 : i + 1) ;
              // tratto lineare chiuso precedente
               vpCrvs[nIndCLprec]->GetEndPoint( ptLineS) ;
               vpCrvs[i]->GetStartPoint( ptLineE) ;
               PtrOwner<ICurveLine> pLinePrec( CreateCurveLine()) ;
               if ( ! IsNull( pLinePrec)  &&  pLinePrec->Set( ptLineS, ptLineE)) {
                  #if DEBUG_OPEN_EDGE_EXTENSION
                     int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pLinePrec->Clone()) ;
                     m_pGeomDB->SetMaterial( a, AQUA) ;
                  #endif
                  if ( ! pCrvNewBorder->AddCurve( Release( pLinePrec)))
                     return false ;
                  pCrvNewBorder->SetCurveTempProp( pCrvNewBorder->GetCurveCount() - 1, 0, TEMP_PROP_CLOSE_EDGE) ;
               }
              // tratto aperto esteso
               #if DEBUG_OPEN_EDGE_EXTENSION
                  int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vpCrvs[i]->Clone()) ;
                  m_pGeomDB->SetMaterial( a, ORANGE) ;
               #endif
               if ( ! pCrvNewBorder->AddCurve( vpCrvs[i]->Clone()))
                  return false ;
              // tratto lineare chiuso successivo
               vpCrvs[i]->GetEndPoint( ptLineS) ;
               vpCrvs[nIndCLsucc]->GetStartPoint( ptLineE) ;
               PtrOwner<ICurveLine> pLineSucc( CreateCurveLine()) ;
               if ( ! IsNull( pLineSucc)  &&  pLineSucc->Set( ptLineS, ptLineE)) {
                  #if DEBUG_OPEN_EDGE_EXTENSION
                     int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pLineSucc->Clone()) ;
                     m_pGeomDB->SetMaterial( a, AQUA) ;
                  #endif
                  if ( ! pCrvNewBorder->AddCurve( Release( pLineSucc)))
                     return false ;
                  pCrvNewBorder->SetCurveTempProp( pCrvNewBorder->GetCurveCount() - 1, 0, TEMP_PROP_CLOSE_EDGE) ;
               }
            }
            else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE) {
               #if DEBUG_OPEN_EDGE_EXTENSION
                  int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, vpCrvs[i]->Clone()) ;
                  m_pGeomDB->SetMaterial( a, AQUA) ;
               #endif
               if ( ! pCrvNewBorder->AddCurve( vpCrvs[i]->Clone()))
                  return false ;
            }
         }
      }
     // ricostruisco il Chunk con il nuovo bordo
      PtrOwner<ISurfFlatRegion> pNewChunk( CreateSurfFlatRegion()) ;
      if ( IsNull( pNewChunk)  ||  ! pNewChunk->AddExtLoop( Release( pCrvNewBorder)))
         return false ;
      for ( int nI = 1 ; nI < vChunks[nC]->GetLoopCount( 0) ; ++ nI) {
         if ( ! pNewChunk->AddIntLoop( vChunks[nC]->GetLoop( 0, nI)))
            return false ;
      }
      vChunks[nC].Set( Release( pNewChunk)) ;
      bModifSfr = true ;
   }

  // recupero la regione finale
   if ( bModifSfr) {
      PtrOwner<ISurfFlatRegion> pSfrTmp( CreateSurfFlatRegion()) ;
      if ( IsNull( pSfrTmp))
         return false ;
      for ( auto& pSfrC : vChunks) {
         if ( pSfrTmp->IsValid())
            pSfrTmp->Add( *pSfrC) ;
         else
            pSfrTmp.Set( pSfrC) ;
      }
      pSfr->CopyFrom( pSfrTmp) ;
   }

   #if DEBUG_OPEN_EDGE_EXTENSION
      DebugDrawSfr( pSfr, false, nLay) ;
   #endif
   return ( pSfr->IsValid()) ;
}

//----------------------------------------------------------------------------
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( 10 * 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()) {
      double dExtension = 4. * m_TParams.m_dDiam + max( 0., m_dOpenMinSafe) + EPS_SMALL ;
      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 ;
            if ( ! GetHomogeneousParts( pCrvLoop, vpCrvs))
               return false ;
           // scorro i tratti omogenei aperti
            for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
               if ( ! IsNull( vpCrvs[i])  && vpCrvs[i]->IsValid()  &&  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(), dExtension, false, false)) ;
                     if ( IsNull( pSfrSubtract)  ||  ! pSfrSubtract->IsValid())
                        return false ;
                     if ( AreOppositeVectorApprox( pSfrSubtract->GetNormVersor(), pSfrPock->GetNormVersor()))
                        pSfrSubtract->Invert() ;
                  }
                  else {
                    // creo la curva di Offset esterna ( deve esistere ed essere valida)
                     vpCrvs[i]->SetExtrusion( pSfrPock->GetNormVersor()) ;
                     OffsetCurve OffsCrv ;
                     PtrOwner<ICurve> pOffsExt( CreateCurveComposite()) ;
                     if ( IsNull( pOffsExt)  ||
                       ! OffsCrv.Make( vpCrvs[i], dExtension, 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], - dExtension, 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::ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm) const
{
  /* Funzione per rimuovere le Part di pStm che non interferiscono con pSfrChunk */
  // Controllo dei parametri
   if ( pSfrChunk == nullptr  ||  ! pSfrChunk->IsValid())
      return false ;
   if ( pStm == nullptr  ||  ! pStm->IsValid())
      return true ;

  // Se solo una Part, allora il grezzo da considerare è tutto
   if ( pStm->GetPartCount() < 2)
      return true ;

  // Recupero la TriMesh ausiliaria del Chunk
   const ISurfTriMesh* pStmAux = pSfrChunk->GetAuxSurf() ;
   if ( pStmAux == nullptr)
      return false ;
   PtrOwner<ISurfTriMesh> pStmChunk( CloneSurfTriMesh( pStmAux)) ;
   if ( IsNull( pStmChunk)  ||  ! pStmChunk->IsValid())
      return false ;
  // Recupero il Box della TriMesh
   BBox3d BBoxChunk ;
   if ( ! pStmChunk->GetLocalBBox( BBoxChunk))
      return false ;

  // Scorro le Part della TriMesh
   for ( int nPart = 0 ; nPart < pStm->GetPartCount() ; ++ nPart) {
     // Recupero il Box della Part corrente
      BBox3d BBoxPart ;
      if ( ! pStm->GetPartLocalBBox( nPart, BBoxPart))
         return false ;
     // Se non c'è intersezione tra i Box, la Part corrente viene rimossa
      BBox3d BBoxInt ;
      if ( ! BBoxPart.FindIntersection( BBoxChunk, BBoxInt)  ||  BBoxInt.IsEmpty()) {
         pStm->RemovePart( nPart) ;
         -- nPart ;
         continue ;
      }
     // Se i Box fanno interferenza verifico in maniera corretta se davvero le superfici interferiscono
      PtrOwner<ISurfTriMesh> pStmPart( pStm->ClonePart( nPart)) ;
      if ( IsNull( pStmPart)  ||  ! pStmPart->IsValid())
         return false ;
      if ( ! TestSurfTmSurfTm( *pStmChunk, *pStmPart, 10. * EPS_SMALL, true)) {
         pStm->RemovePart( nPart) ;
         -- nPart ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
{
  /* Bisogna distingere tra lati aperti sul bordo del grezzo e lati aperti all'interno del grezzo ;
  *  I lati aperti all'interno del grezzo vanno estesi di circa il raggio utensile e poi considerati
  *  come chiusi */

  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||
        pStm == nullptr)
      return false ;
   if ( ! pStm->IsValid())
      return true ;

  // Recupero dalle Note utenti il parametro OpenOutRaw
   int nOpenOutRaw ;
   m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw)  &&  nOpenOutRaw != 0) ;

  // recupero i Chunk della superficie
   ISURFFRPOVECTOR vChunks( pSfr->GetChunkCount()) ;
   for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC)
      vChunks[nC].Set( pSfr->CloneChunk( nC)) ;

  // definisco un frame locale nel piano XY
   Frame3d frXY ;
   Point3d ptCenter ; pSfr->GetCentroid( ptCenter) ;
   if ( ! frXY.Set( ptCenter, pSfr->GetNormVersor()))
      return false ;

  // definisco Offset di tolleranza
   m_dOpenInRawExtension = 1.05 * ( m_TParams.m_dDiam / 2.) ;
   double dOpenExtension = 0. ;
   if ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, dOpenExtension)  &&  dOpenExtension > EPS_SMALL)
      m_dOpenInRawExtension = dOpenExtension ;

  // se la superficie ha flag di OpenOutRaw e non è stata impostata alcuna estensione massima,
  // non modifico la geometria, lascio l'aperto esattamente dove si trova
  // se invece ho flat di OpenOutRaw, dato che il lato aperto viene lasciato tale, devo ridurre la
  // sua estensione del raggio utensile
   if ( m_bOpenOutRaw) {
      if ( dOpenExtension < 10. * EPS_SMALL)
         return true ;
      else {
         m_dOpenInRawExtension -= m_TParams.m_dDiam / 2. ;
         if ( m_dOpenInRawExtension < EPS_SMALL) {
            m_dOpenInRawExtension = 0. ;
            return true ;
         }
      }
   }

   const double LEN_EXTENSION = 1000. ;
   const double TOL_PT_INSIDE_STM = 3. ;
   #if DEBUG_OPEN_EDGE_IN_RAW
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "_OpenEdgeInRaw") ;
      int nLayBase = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLayBase, "Orig") ;
      int nLayConstr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLayConstr, "Construction") ;
      int nLayResult = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLayResult, "Result") ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayBase, pStm->Clone()) ;
      m_pGeomDB->SetMaterial( _a, Color( .35, .65, .45, .35)) ;
   #endif

  // recupero solo la curva di bordo esterno, le isole aperte per ora sono trascurate
  // scorro i Chunk della regione piana da lavorare
   bool bModifSfr = false ;
   for ( int nC = 0 ; nC < int( vChunks.size()) ; ++ nC) {
     // recupero la curva di bordo
      PtrOwner<ICurveComposite> pCrvBorder( ConvertCurveToComposite( vChunks[nC]->GetLoop( 0, 0))) ;
      if ( IsNull( pCrvBorder)  ||  ! pCrvBorder->IsValid())
         return false ;
     // recupero i tratti omogenei
      ICRVCOMPOPOVECTOR vpCrvs ;
      GetHomogeneousParts( pCrvBorder, vpCrvs) ;
     // se tutta chiusa, non faccio nulla
      if ( int( vpCrvs.size()) == 1  &&  vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE)
         continue ;
     // scorro i tratti alla ricerca di lati aperti ( esistono necessariamente)
      bool bOpenCrvInPart = false ;
      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
         if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE) {
           // analizzo le sottocurve del tratto
            for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j) {
              // per ogni sottocurva considero punto iniziale, finale e medio per campionarla
              // ( si potrebbe in futuro campionare in maniera più fitta )
               PNTVECTOR vPt( 3, P_INVALID) ;
               vpCrvs[i]->GetCurve( j)->GetStartPoint( vPt[0]) ;
               vpCrvs[i]->GetCurve( j)->GetMidPoint( vPt[1]) ;
               vpCrvs[i]->GetCurve( j)->GetEndPoint( vPt[2]) ;
              // classifico tali punti rispetto alla superficie
               bool bOpenEdgeInStm = false ;
               double dDist = 0. ;
               for ( int nPt = 0 ; nPt < int( vPt.size()) && ! bOpenEdgeInStm ; ++ nPt) {
                  DistPointSurfTm DistPtStm( vPt[nPt], *pStm) ;
                  bOpenEdgeInStm = ( DistPtStm.IsPointInside()  &&
                                     DistPtStm.GetDist( dDist)  &&
                                     dDist > TOL_PT_INSIDE_STM) ;
               }
              // se curva aperta nel pezzo, la classifico
               if ( bOpenEdgeInStm) {
                  vpCrvs[i]->SetCurveTempProp( j, TEMP_PROP_OPEN_EDGE_IN_RAW, 0) ;
                  bOpenCrvInPart = true ;
               }
            }
         }
      }
     // se non sono state trovate curve interne al pezzo, allora passo al bordo successivo
      if ( ! bOpenCrvInPart)
         continue ;
     // ricostruisco il bordo mediante proprietà assegnate ( esistono lati aperti interni al pezzo)
      PtrOwner<ICurveComposite> pCrvNewBorder( CreateCurveComposite()) ;
      if ( IsNull( pCrvNewBorder))
         return false ;
      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
         if ( ! pCrvNewBorder->AddCurve( Release( vpCrvs[i])))
            return false ;
      }
     // recupero i nuovi tratti omogenei
      GetHomogeneousParts( pCrvNewBorder, vpCrvs) ;
      #if DEBUG_OPEN_EDGE_IN_RAW
         DebugDrawOpenEdgesInRaw( vpCrvs, nLayBase) ;
      #endif
     // caso limite : tutta la curva è aperta ed interna alla regione
      if ( int( vpCrvs.size()) == 1  &&  vpCrvs[0]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW) {
        // Offset del bordo del Chunk
         OffsetCurve OffsCrv ;
         OffsCrv.Make( pCrvNewBorder, m_dOpenInRawExtension, ICurve::OFF_FILLET) ;
         pCrvNewBorder.Set( ConvertCurveToComposite( OffsCrv.GetLongerCurve())) ;
         if ( IsNull( pCrvNewBorder)  ||  ! pCrvNewBorder->IsValid())
            return false ;
        // considero il bordo come tutto chiuso ( evito entrate da fuori dal pezzo)
         for ( int i = 0 ; i < pCrvNewBorder->GetCurveCount() ; ++ i)
            pCrvNewBorder->SetCurveTempProp( i, m_bOpenOutRaw ? TEMP_PROP_OPEN_EDGE : TEMP_PROP_CLOSE_EDGE, 0) ;
      }
     // se invece presenta solo alcuni tratti Open interni al pezzo
      else {
        // porto tutti i tratti ricavati nel piano XY per le intersezioni
         for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i)
            vpCrvs[i]->ToLoc( frXY) ;
        // scorro i tratti con proprietà uniformi
         bool bOk = true ;
         for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
            if ( ! bOk) {
              // considero il tratto precedente come chiuso
               for ( int j = 0 ; j < vpCrvs[i-1]->GetCurveCount() ; ++ j)
                  vpCrvs[i-1]->SetCurveTempProp( j, TEMP_PROP_CLOSE_EDGE, 0) ;
               bOk = true ;
            }
           // se tratto Open interno al grezzo
            if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW) {
              // effettuo Offset del tratto in esame
               OffsetCurve OffsCrv ;
               OffsCrv.Make( vpCrvs[i], m_dOpenInRawExtension, ICurve::OFF_FILLET) ;
               PtrOwner<ICurveComposite> pCrvOffsOpenInPart( ConvertCurveToComposite( OffsCrv.GetLongerCurve())) ;
               if ( IsNull( pCrvOffsOpenInPart)  ||  ! pCrvOffsOpenInPart->IsValid()) {
                  bOk = false ;
                  continue ;
               }
              // recupero tratto precedente e successivo
               int nIndPrev = ( i > 0 ? i - 1 : int( vpCrvs.size()) - 1) ;
               int nIndAfter = ( i < int( vpCrvs.size()) - 1 ?  i + 1 : 0) ;
              // estendo per sicurezza il tratto di Offset ( per angoli acuti con i tratti adiacenti)
               pCrvOffsOpenInPart->ExtendStartByLen( LEN_EXTENSION) ;
               pCrvOffsOpenInPart->ExtendEndByLen( LEN_EXTENSION) ;
               #if DEBUG_OPEN_EDGE_IN_RAW
                  int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pCrvOffsOpenInPart->Clone()) ;
                  m_pGeomDB->SetMaterial( _a, ORANGE) ;
               #endif
              // definisco due segmenti lineari
               PtrOwner<ICurveLine> pLinePrev( CreateCurveLine()) ;
               PtrOwner<ICurveLine> pLineAfter( CreateCurveLine()) ;
               if ( IsNull( pLinePrev)  ||  IsNull( pLineAfter))
                  return false ;
               Point3d ptLineStart ;
               Vector3d vtLineStart ;
               vpCrvs[nIndPrev]->GetEndPoint( ptLineStart) ;
               vpCrvs[nIndPrev]->GetEndDir( vtLineStart) ;
               if ( ! pLinePrev->Set( ptLineStart, ptLineStart + LEN_EXTENSION * vtLineStart))
                  return false ;
               #if DEBUG_OPEN_EDGE_IN_RAW
                  _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pLinePrev->Clone()) ;
                  m_pGeomDB->SetMaterial( _a, BLACK) ;
               #endif
               Point3d ptLineEnd ;
               Vector3d vtLineEnd ;
               vpCrvs[nIndAfter]->GetStartPoint( ptLineEnd) ;
               vpCrvs[nIndAfter]->GetStartDir( vtLineEnd) ;
               if ( ! pLineAfter->Set( ptLineEnd - LEN_EXTENSION * vtLineEnd, ptLineEnd))
                  return false ;
               #if DEBUG_OPEN_EDGE_IN_RAW
                  _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayConstr, pLineAfter->Clone()) ;
                  m_pGeomDB->SetMaterial( _a, BLACK) ;
               #endif
              // intersezione con primo segmento ( raccordo verso lato Open In Raw Offs)
               Point3d ptIntS ;
               double dUS_Trim_Line ;
               double dUS_Trim_Offs ;
               IntersCurveCurve ICC_Prev( *pLinePrev, *pCrvOffsOpenInPart) ;
               if ( ICC_Prev.GetIntersCount() > 0  &&  ICC_Prev.GetIntersPointNearTo( 0, ptLineStart, ptIntS)) {
                  pLinePrev->GetParamAtPoint( ptIntS, dUS_Trim_Line) ;
                  pCrvOffsOpenInPart->GetParamAtPoint( ptIntS, dUS_Trim_Offs) ;
               }
               else {
                  bOk = false ;
                  continue ;
               }
              // intersezione con secondo segmento ( raccordo da Lato Open In Raw Offs)
               Point3d ptIntE ;
               double dUE_Trim_Line ;
               double dUE_Trim_Offs ;
               IntersCurveCurve ICC_After( *pLineAfter, *pCrvOffsOpenInPart) ;
               if ( ICC_After.GetIntersCount() > 0  &&  ICC_After.GetIntersPointNearTo( 0, ptLineEnd, ptIntE)) {
                  pLineAfter->GetParamAtPoint( ptIntE, dUE_Trim_Line) ;
                  pCrvOffsOpenInPart->GetParamAtPoint( ptIntE, dUE_Trim_Offs) ;
               }
               else {
                  bOk = false ;
                  continue ;
               }
              // se le rette si intersecano tra loro prima di raccordarsi sull'Offset
               if ( dUS_Trim_Offs > dUE_Trim_Offs) {
                 // recupero punto di intersezione tra le rette
                  IntersCurveCurve ILL( *pLinePrev, *pLineAfter) ;
                  Point3d ptIntersLL ;
                  if ( ILL.GetIntersCount() != 1  ||
                       ! ILL.GetIntersPointNearTo( 0, ptLineStart, ptIntersLL)  ||
                       ! pLinePrev->GetParamAtPoint( ptIntersLL, dUS_Trim_Line)  ||
                       ! pLineAfter->GetParamAtPoint( ptIntersLL, dUE_Trim_Line)) {
                     bOk = false ;
                     continue ;
                  }
                 // pulisco la curva di Offset
                  pCrvOffsOpenInPart->Clear() ;
               }
              // se le rette non si intersecano tra loro
               else {
                  double dU_Offs_Trim_Start = 0. ;
                  pCrvOffsOpenInPart->GetParamAtPoint( ptIntS, dU_Offs_Trim_Start) ;
                  pCrvOffsOpenInPart->TrimStartAtParam( dU_Offs_Trim_Start) ;
                  double dU_Offs_Trim_End = 0. ;
                  pCrvOffsOpenInPart->GetParamAtPoint( ptIntE, dU_Offs_Trim_End) ;
                  pCrvOffsOpenInPart->TrimEndAtParam( dU_Offs_Trim_End) ;
               }
              // aggiorno tutte le curve e le loro proprietà
               pLinePrev->TrimEndAtParam( dUS_Trim_Line) ;
               pLinePrev->SetTempProp( vpCrvs[nIndPrev]->GetTempProp( 0), 0) ;
               vpCrvs[nIndPrev]->AddCurve( Release( pLinePrev), true) ;
               pLineAfter->TrimStartAtParam( dUE_Trim_Line) ;
               pLineAfter->SetTempProp( vpCrvs[nIndAfter]->GetTempProp( 0), 0) ;
               vpCrvs[nIndAfter]->AddCurve( Release( pLineAfter), false) ;
               vpCrvs[i].Set( Release( pCrvOffsOpenInPart)) ;
              // assegno proprietà di lato aperto/chiuso
               for ( int j = 0 ; j < vpCrvs[i]->GetCurveCount() ; ++ j)
                  vpCrvs[i]->SetCurveTempProp( j, m_bOpenOutRaw ? TEMP_PROP_OPEN_EDGE : TEMP_PROP_CLOSE_EDGE, 0) ;
            }
         }
        // ricostrusico il nuovo bordo
         pCrvNewBorder->Clear() ;
         #if DEBUG_OPEN_EDGE_IN_RAW
            DebugDrawOpenEdgesInRaw( vpCrvs, nLayResult) ;
         #endif
         for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
            if ( ! IsNull( vpCrvs[i])  &&  vpCrvs[i]->IsValid()  &&  vpCrvs[i]->GetCurveCount() > 0) {
               if ( ! pCrvNewBorder->AddCurve( Release( vpCrvs[i])))
                  return false ;
            }
         }
        // lo riporto nel frame globale
         pCrvNewBorder->ToGlob( frXY) ;
      }
     // ricostruisco il Chunk con il nuovo bordo
      PtrOwner<ISurfFlatRegion> pNewChunk( CreateSurfFlatRegion()) ;
      if ( IsNull( pNewChunk)  ||  ! pNewChunk->AddExtLoop( Release( pCrvNewBorder)))
         return false ;
      for ( int nI = 1 ; nI < vChunks[nC]->GetLoopCount( 0) ; ++ nI) {
         if ( ! pNewChunk->AddIntLoop( vChunks[nC]->GetLoop( 0, nI)))
            return false ;
      }
      vChunks[nC].Set( Release( pNewChunk)) ;
      bModifSfr = true ;
   }

  // recupero la regione finale
   if ( bModifSfr) {
      PtrOwner<ISurfFlatRegion> pSfrTmp( CreateSurfFlatRegion()) ;
      if ( IsNull( pSfrTmp))
         return false ;
      for ( auto& pSfrC : vChunks) {
         if ( pSfrTmp->IsValid())
            pSfrTmp->Add( *pSfrC) ;
         else
            pSfrTmp.Set( pSfrC) ;
      }
      pSfr->CopyFrom( pSfrTmp) ;
   }

   #if DEBUG_OPEN_EDGE_IN_RAW
      DebugDrawSfr( pSfr, false, nLayResult) ;
   #endif
   return ( pSfr->IsValid()) ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool,
                            const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion,
                            const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth)
{
  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid()  ||
        pStmRaw == nullptr  ||  ! pStmRaw->IsValid()  ||
        pStmExtrusion == nullptr)
      return false ;
   bSkipMaxDepth = false ;

   #if DEBUG_MAXDEPTH
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "MaxDepth") ;
      int nLaySfr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLaySfr, "Sfr") ;
      DebugDrawSfr( pSfr, false, nLaySfr) ;
      int nLayRaw = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLayRaw, "Raw") ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayRaw, pStmRaw->Clone()) ;
      m_pGeomDB->SetMaterial( _a, Color( 0., 0., 1., .35)) ;
   #endif

  // se la superficie di estrusione dei chiusi è vuota
   if ( ! pStmExtrusion->IsValid()  ||  pStmExtrusion->GetTriangleCount() == 0) {
      bSkipMaxDepth = true ;
      return true ;
   }

   #if DEBUG_MAXDEPTH
      int nLayStmExtr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "StmExtrusion") ;
      _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayStmExtr, pStmExtrusion->Clone()) ;
      m_pGeomDB->SetMaterial( _a, AQUA) ;
   #endif

  // adatto la regione piana attuale al grezzo
  // NB. La pStmExtrusion potrebbe esistere ma non toccare nessun lato adattato al grezzo
   PtrOwner<ISurfFlatRegion> pSfrRaw( GetSfrByStmIntersection( IPPStm, - dDepth, 0)) ;
   if ( IsNull( pSfrRaw)) {
      m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
      return false ;
   }
   if ( ! pSfrRaw->IsValid()  ||  pSfrRaw->GetChunkCount() == 0)
      return true ; // ??? ( non deve capitare)
   PtrOwner<ISurfFlatRegion> pSfrAdj( CloneSurfFlatRegion( pSfr)) ;
   if ( IsNull( pSfrAdj)  ||  ! pSfrAdj->IsValid()  ||
        ! pSfrAdj->Translate( - dDepth * vtTool))
      return false ;
   pSfrAdj->Intersect( *pSfrRaw) ;
   if ( ! pSfrAdj->IsValid())
      return true ; // ??? ( non deve capitare)

  // determino i lati aperti della regione ricavata
   if ( ! ChooseCloseOrOpenEdge( pSfrAdj, pStmExtrusion)) {
      m_pMchMgr->SetLastError( 3026, "Error in PocketingNT : Detecting open edges failed") ;
      return false ;
   }

   #if DEBUG_MAXDEPTH
      nLaySfr = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLaySfr, "Sfr_Raw_Inters") ;
      DebugDrawSfr( pSfr, true, nLaySfr) ;
   #endif

  // controllo se la regione ha tutti i lati aperti
   int nTmpProp = TEMP_PROP_INVALID ;
   for ( int nC = 0 ; nC < pSfrAdj->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfrAdj->GetLoopCount( nL) ; ++ nL) {
         for ( int nU = 0 ; nU < pSfrAdj->GetLoopCurveCount( nC, nL) ; ++ nU) {
            if ( pSfrAdj->GetCurveTempProp( nC, nL, nU, nTmpProp, 0)  &&
                 nTmpProp == TEMP_PROP_CLOSE_EDGE) {
               return true ;
            }
         }
      }
   }
   bSkipMaxDepth = true ;
   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 ;
   ISurfFlatRegion* pSfr( GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;

  // assegno le proprietà di lato aperto ai suoi 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) {
      vtExtr.Invert() ;
      dThick = - dThick ;
      pSfr->Invert() ;
   }

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

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

  // calcolo l'elevazione inversa per definire la Depth massima
   double dInvElev = 0. ;
   pSfr->Invert() ;
   if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
      m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
      return false ;
   }
   pSfr->Invert() ;
   double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ;
   if ( dOkStep < EPS_SMALL)
      dExtraDepth = EXTRA_DEPTH ;
   dDepth = min( dDepth, dInvElev + dExtraDepth) ;

  // calcolo l'elevazione massima
   double dElev = 0. ;
   if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
      m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
      return false ;
   }
   double dMaxElev ;
   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev)
      dElev = dMaxElev ;

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

  // recupero il grezzo e la superficie di Trim [nullptr se non presente]
   PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
   if ( IsNull( pStmRaw)  ||  ! ChooseRawPart( pSfr, pStmRaw)  ||
        ! pStmRaw->IsValid()  ||  pStmRaw->GetTriangleCount() == 0) {
      m_pMchMgr->SetLastError( 3025, "Error in PocketingNT : RawPart not computable") ;
      return false ;
   }
   PtrOwner<ISurfTriMesh> pStmTrim( GetStmTrim()) ;
   if ( ! IsNull( pStmTrim)) {
      if ( ! ChooseRawPart( pSfr, pStmTrim)  ||  ! pStmTrim->IsValid()  ||
           pStmTrim->GetTriangleCount() == 0) {
         m_pMchMgr->SetLastError( 3025, "Error in PocketingNT : RawPart not computable") ;
         return false ;
      }
   }
   #if DEBUG_SFR_RAW
      int nGrpSR = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLaySR = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpSR, GLOB_FRM) ;
      m_pGeomDB->SetName( nLaySR, "Sfr_Raw_Position") ;
      int _nRaw = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pStmRaw->Clone()) ;
      m_pGeomDB->SetMaterial( _nRaw, Color( .35, .46, .78, .1)) ;
      if ( ! IsNull( pStmTrim)) {
         int _nTrim = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pStmTrim->Clone()) ;
         m_pGeomDB->SetMaterial( _nTrim, Color( .65, .26, .58, .1)) ;
      }
   #endif

  // definisco una trimesh derivante dalla regione piana mediante estrusione dei lati chiusi
  // NB. La traslazione in questo caso è euristica
  // NB. Questa superficie servirà per definire i lati chiusi una volta che la regione piana
  //     è stata intersecata con la superficie del grezzo
   pSfr->Translate( - vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
   Vector3d vtStmExtr = vtTool * ( abs( dDepth) + m_TParams.m_dMaxMat + dElev + m_TParams.m_dMaxMat) ;
   PtrOwner<ISurfTriMesh> pStmExtrusion( GetExtrusionStm( pSfr, vtStmExtr)) ;
   pSfr->Translate( vtTool * ( dDepth + m_TParams.m_dMaxMat)) ;
   if ( IsNull( pStmExtrusion))
      return false ;
   #if DEBUG_STM_EXTRUSION
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLay, "Extr_Stm_Close_edge") ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pStmExtrusion->Clone()) ;
      m_pGeomDB->SetMaterial( _a, Color( 1., 0., 1., .75)) ;
      m_pGeomDB->SetStatus( _a, GDB_ST_OFF) ;
   #endif

  // 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 Pocketing : 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) {
        // controllo se posso evitare il controllo
         Frame3d frSfr ;
         Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
         Frame3d frPocket ;
         if ( ! frPocket.Set( ptCen, vtTool)  ||  ! frPocket.IsValid())
            return false ;
         IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ;
         bool bSkipMaxDepth = false ;
         if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth))
            return false ;
         if ( ! bSkipMaxDepth) {
           // 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 ;
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nL) ; ++ nL) {
        // recupero la curva
         PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
            return false ;
        // se isola inverto
         if ( nL > 0)
            pCrvLoop->Invert() ;
        // verifica
         if ( ! VerifyPathFromBottom( pCrvLoop, vtTool))
            return false ;
      }
   }

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

  // recupero eventuale minima lunghezza di attacco su lato aperto
   m_dOpenMinSafe = 5. ;
   GetValInNotes( m_Params.m_sUserNotes, UN_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) ;

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

     // step per progressBar
      int nProgressBarStep = 0 ;

     // vettore per gli step
      STEPINFOPOVECTOR vStepInfo ;

      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> pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfrPock, vtTool)) ;
         if ( IsNull( pSfrTrim)) {
            m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
            return false ;
         }
         if ( pSfrTrim->IsValid()  &&  pSfrTrim->GetChunkCount() > 0) {
           // se valida, limito la superficie di svuotatura alla proiezione del grezzo
            #if DEBUG_SFR_RAW
               int _nSfr = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLaySR, pSfrTrim->Clone()) ;
               m_pGeomDB->SetMaterial( _nSfr, Color( 0., 1., 0., .75)) ;
            #endif
            pSfrPock->Intersect( *pSfrTrim) ;
         }
         else
            continue ; // svuotatura fuori dalla proiezione del grezzo, passo al prossimo step

        // 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 DEBUG_SFR_STEPS
               int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
               int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
               m_pGeomDB->SetName( nLay, "Sfr_Pocketing") ;
               DebugDrawSfr( pSfrPock, false, nLay) ;
            #endif
           // determino la regione limite
            PtrOwner<ISurfFlatRegion> pSfrLimit( CreateSurfFlatRegion()) ;
            if ( IsNull( pSfrLimit)  ||
                 ! CalcLimitRegion( pSfrPock, pSfrTrim, pSfrLimit)) {
               m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Calc limit region failed") ;
               return false ;
            }
            #if DEBUG_SFR_STEPS
               int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrLimit->Clone()) ;
               m_pGeomDB->SetMaterial( _a, Color( .5, .5, .5, .5)) ;
            #endif
           // 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) ;
         }
        // 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 ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth,
                                  double dRad, double dLen, double& dElev)
{
  // controllo dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
  // inizializzo l'elevazione
   dElev = 0. ;

  // recupero tutti i loop della regione
   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; ++ nC) {
      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; ++ nL) {
        // recupero la curva
         PtrOwner<ICurveComposite> pCrvLoop( ConvertCurveToComposite( pSfr->GetLoop( nC, nL))) ;
         if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
            return false ;
        // se isola inverto
         if ( nL > 0)
            pCrvLoop->Invert() ;
        // approssimo la curva con una polilinea che uso per creare il poligono equivalente
         PolyLine PL ;
         if ( ! pCrvLoop->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 l'elevazione corrente
         double dMyElev = 0. ;

        // 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( dMyElev * vtTool) ;
               if ( b3Raw.Overlaps( b3CurrTool))
                  dMyElev = vRawElev[i].second ;
            }
         }
         dElev = max( dElev, dMyElev) ;
      }
   }

   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::CalcRetCurve( PathInfoPO& PathInfo, const StepInfoPO& StepInfo, const ICurveComposite* pCrvPath,
                           const Vector3d& vtTool, bool bHolePocketing, bool bInVsOut, ICurveComposite* pCrvGlide)
{
  /* Funzione per il calcolo della curva a sciovolo (piana) in entrata o in uscita
     pCrvGlide = nullptr */

  // controllo dei parametri
   if ( pCrvPath == nullptr  ||  ! pCrvPath->IsValid()  ||
        pCrvGlide == nullptr)
      return false ;

  // se caso speciale curva a spirale
   if ( bHolePocketing) {
      Point3d ptStart ; pCrvPath->GetStartPoint( ptStart) ;
      Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
      if ( ! AreSamePointApprox( ptStart, ptEnd)) {
         Vector3d vtStart ; pCrvPath->GetStartDir( vtStart) ;
         PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
         if ( IsNull( pArc)  ||  ! pArc->Set2PVN( ptStart, ptEnd, - vtStart, vtTool)) {
            m_pMchMgr->SetLastError( 2420, "Error in Pocketing : Return toolpath not computable") ;
            return false ;
         }
        // inverto
         pArc->Invert() ;
        // definisco la curva per lo scivolo
         PtrOwner<ICurveComposite> pCrvGlideTmp( CreateCurveComposite()) ;
         if ( IsNull( pCrvGlideTmp)  ||  !  pCrvGlideTmp->AddCurve( Release( pArc)))
            return false ;
        // calcolo la curva in base ai parametri
         double dLen = 0. ; pCrvGlideTmp->GetLength( dLen) ;
         double dParS, dParE ; pCrvGlideTmp->GetDomain( dParS, dParE) ;
         double dU ;
        // se LeadIn a scivolo, recupero il parametro sulla curva
         if ( bInVsOut) {
            if ( GetLeadInType() == POCKET_LI_GLIDE) {
               if ( ! pCrvGlideTmp->GetParamAtLength( dLen - m_Params.m_dLiTang, dU))
                  dU = 0. ;
               pCrvGlide->AddCurve( pCrvGlideTmp->CopyParamRange( dU, dParE)) ;
            }
            else
               dU = dParE ;
           // calcolo la curva di ritorno
            PtrOwner<ICurveComposite> pCrvRet( ConvertCurveToComposite( pCrvGlideTmp->CopyParamRange( dParS, dU))) ;
            if ( ! IsNull( pCrvRet)  &&  pCrvRet->IsValid()) {
               if ( ! PathInfo.pCrvRet.Set( Release( pCrvRet)))
                  return false ;
            }
         }
        // Se LeadOut a scivolo
         else {
            if ( GetLeadOutType() == POCKET_LO_GLIDE) {
               if ( ! pCrvGlideTmp->GetParamAtLength( m_Params.m_dLoTang, dU))
                  dU = dParE ;
               pCrvGlide->AddCurve( pCrvGlideTmp->CopyParamRange( dParS, dU)) ;
               if ( ! pCrvGlide->IsValid())
                  return false ;
            }
         }
      }
     // non c'è bisogno di verificare nulla con la regione limite
      return true ;
   }
  // se regione di svuotatura generica
   else {
     // Entrata a Scivolo
      if ( bInVsOut) {
        // se l'entrata non è a scivolo, non faccio nulla
         if ( GetLeadInType() != POCKET_LI_GLIDE)
            return true ;
        // se l'entrata è presso un lato aperto, non faccio nulla
         if ( PathInfo.bOutStart)
            return true ;
        // l'entrata a scivolo viene eseguita nel caso di percorsi SpiralIn/Out o curve di bordo chiuse
         if ( ( PathInfo.bSingleCrv  &&  ! pCrvPath->IsClosed())  ||
              ( PathInfo.bOptTrap  &&  ! pCrvPath->IsClosed())  ||
              ( PathInfo.bIsZigZagOneWayBorder  &&  ! pCrvPath->IsClosed()))
            return true ;
        // inizializzo e recupero il percorso :
         PtrOwner<ICurveComposite> pCrvGlideIn( CreateCurveComposite()) ;
         if ( IsNull( pCrvGlideIn))
            return false ;
        // se chiuso
         if ( pCrvPath->IsClosed())
            pCrvGlideIn->CopyFrom( pCrvPath) ;
        // se aperto
         else {
           // potrebbe esserci un percorso interno chiuso, lo cerco
            Point3d ptStart ; pCrvPath->GetStartPoint( ptStart) ;
            int nCrv = 0 ;
            bool bOk = false ;
            for ( ; nCrv < pCrvPath->GetCurveCount() ; ++ nCrv) {
               const ICurve* pCrv = pCrvPath->GetCurve( nCrv) ;
               if ( pCrv == nullptr)
                  return false ;
               Point3d ptEnd ; pCrv->GetEndPoint( ptEnd) ;
               if ( AreSamePointApprox( ptStart, ptEnd)) {
                  ++ nCrv ;
                  bOk = true ;
                  break ;
               }
            }
           // se non trovato, non faccio nulla
            if ( ! bOk)
               return true ;
           // altrimenti, lo memorizzo
            pCrvGlideIn.Set( ConvertCurveToComposite( pCrvPath->CopyParamRange( 0, nCrv))) ;
         }
        // se percorso a guida non valido, non faccio nulla
         if ( IsNull( pCrvGlideIn)  ||  ! pCrvGlideIn->IsValid())
            return true ;
        // controllo che la lunghezza del percorso sia compatibile
         double dLen = 0. ;
         if ( pCrvGlideIn->GetLength( dLen)  &&  dLen < m_Params.m_dLiTang + 10 * EPS_SMALL)
            return true ;
        // recupero il tratto di curva alla fine
         double dU, dParS, dParE ;
         if ( ! pCrvGlideIn->GetParamAtLength( dLen - m_Params.m_dLiTang, dU)  ||
              ! pCrvGlideIn->GetDomain( dParS, dParE))
            return false ;
         pCrvGlide->AddCurve( pCrvGlideIn->CopyParamRange( dU, dParE)) ;
         if ( ! pCrvGlide->IsValid())
            return false ;
      }
     // Uscita a scivolo
      else {
        // se l'uscita non è a scivolo, non faccio nulla
         if ( GetLeadOutType() != POCKET_LO_GLIDE)
            return true ;
        // se l'uscita è presso un lato aperto, non faccio nulla
         if ( PathInfo.bOutEnd)
            return true ;
        // se l'uscita è a scivolo e sono in un caso a trapezio, non faccio nulla
         if ( PathInfo.bOptTrap)
            return true ;
        // inizializzo e recupero il percorso :
         PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
         if ( IsNull( pCrvGlideOut))
            return false ;
        // se il tratto è chiuso
         if ( pCrvPath->IsClosed())
            pCrvGlideOut->CopyFrom( pCrvPath) ;
        // se aperto
         else {
           // percorro a ritroso il percorso cercano una curva che inizi presso la fine del percorso
            Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
            int nCrv = pCrvPath->GetCurveCount() - 1 ;
            bool bOk = false ;
            for ( ; nCrv >= 0 ; -- nCrv) {
               const ICurve* pCrv = pCrvPath->GetCurve( nCrv) ;
               if ( pCrv == nullptr)
                  return false ;
               Point3d ptStart ; pCrv->GetStartPoint( ptStart) ;
               if ( AreSamePointApprox( ptEnd, ptStart)) {
                  bOk = true ;
                  break ;
               }
            }
           // se trovata, la memorizzo
            if ( bOk) {
               PtrOwner<ICurveComposite> pCrvTmp( ConvertCurveToComposite( pCrvPath->CopyParamRange( nCrv, pCrvPath->GetCurveCount() - 1))) ;
               if ( ! IsNull( pCrvTmp)  &&  pCrvTmp->IsValid()) {
                  pCrvGlideOut.Set( Release( pCrvTmp)) ;
               }
            }
         }
        // se curva valida
         if ( ! IsNull( pCrvGlideOut)  &&  pCrvGlideOut->IsValid()) {
            // controllo che la lunghezza del percorso sia compatibile
               double dLen = 0. ;
            if ( pCrvGlideOut->GetLength( dLen)  &&  dLen > m_Params.m_dLoTang + 10 * EPS_SMALL) {
              // recupero il tratto di curva alla fine
               double dU = 0. ;
               if ( ! pCrvGlideOut->GetParamAtLength( m_Params.m_dLoTang, dU))
                  return false ;
               pCrvGlide->AddCurve( pCrvGlideOut->CopyParamRange( 0., dU)) ;
            }
           // se non sufficientemente lunga, la guida diventa la curva stessa
            else
               pCrvGlide->AddCurve( Release( pCrvGlideOut)) ;

            if ( ! pCrvGlide->IsValid())
                  return false ;
         }
        // se curva non valida, provo con estensione lineare ( TODO : arco ?)
         else {
            Point3d ptEnd ; pCrvPath->GetEndPoint( ptEnd) ;
            Vector3d vtEnd ; pCrvPath->GetEndDir( vtEnd) ;
            PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
            if ( IsNull( pCrvGlideOut)  || 
                 ! pCrvGlideOut->AddPoint( ptEnd)  ||
                 ! pCrvGlideOut->AddLine( ptEnd + m_Params.m_dLoTang * vtEnd)  ||
                 ! pCrvGlideOut->IsValid())
               return false ;
            pCrvGlide->CopyFrom( pCrvGlideOut) ;
            if ( ! pCrvGlide->IsValid())
               return false ;
         }
      }
   }

   #if DEBUG_GLIDE
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLay, "Glide_Crv") ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvPath->Clone()) ;
      m_pGeomDB->SetMaterial( _a, GREEN) ;
      _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvGlide->Clone()) ;
      m_pGeomDB->SetMaterial( _a, bInVsOut ? LIME : FUCHSIA) ;
   #endif

  // verifico che il percorso sia al di fuori della regione limite
   if ( StepInfo.pSfrPock != nullptr  &&  StepInfo.pSfrPock->IsValid()) {
      #if DEBUG_GLIDE
         _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, StepInfo.pSfrPock->Clone()) ;
         m_pGeomDB->SetMaterial( _a, Color( 0., 1., 0., .35)) ;
      #endif
      if ( ! VerifyLeadInOutGlide( StepInfo.pSfrPock, pCrvGlide))
         pCrvGlide->Clear() ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo)
{
  // se non ho Step, non faccio nulla
   if ( vStepInfo.empty())
      return true ;

  // punto finale di riferimento per il percorso attuale ( serve per trovare il punto iniziale
  // del percorso successivo). Parto analizzando la testa ( da sopra/da sotto)
   Point3d ptStartRef = GetStartPointsByHead( vStepInfo) ;
  // --- se punto invalido e raggio utensile grande se raggio utensile grande
   if ( ! ptStartRef.IsValid()  &&  m_TParams.m_dDiam / 2. > TOOL_RAD_PTSTART - EPS_ZERO) {
     // cerco l'ingresso in base alla geometria iniziale della tasca
      ptStartRef = GetStartPointsFromSteps( vStepInfo, TEMP_PROP_OPEN_EDGE) ;
      if ( ! ptStartRef.IsValid())
         ptStartRef = GetStartPointsFromSteps( vStepInfo, TEMP_PROP_CLOSE_EDGE) ;
   }

  // recupero flag per casi ottimizzati
   double dMaxOptSize = m_Params.m_dSideStep ;
   GetValInNotes( m_Params.m_sUserNotes, UN_MAXOPTSIZE, dMaxOptSize) ;

  // recupero flag per calcolo delle Feed
   bool bAdjustFeed = true ;
   GetValInNotes( m_Params.m_sUserNotes, UN_ADJUSTFEED, bAdjustFeed) ;

  // 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, GetOffsR(), GetSideStep(),
                            m_Params.m_dSideAngle, m_dOpenMinSafe, m_Params.m_nSubType, true, true, m_Params.m_bInvert,
                            false, true, bAdjustFeed, ptStartRef, vStepInfo[i].pSfrLimit, false, dMaxOptSize,
                            m_Params.m_dLiTang, GetLeadInType(), vCrvPaths)) {
         m_pMchMgr->SetLastError( 3028, "Error in PocketingNT : Error in CalcPocketing") ;
         return false ;
      }
     // se non ho ottenuto percorsi, errore
      if ( vCrvPaths.empty())
         return false ;
     // sistemo gli archi per massimo angolo al centro
      for ( int j = 0 ; j < int( vCrvPaths.size()) ; ++ j)
         VerifyArcs( vCrvPaths[j]) ;
     // 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) ;
         if ( ! vStepInfo[i].vPaths[j].bOutStart  &&  ! LeadInRawIsOk()) {
            m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
            return false ;
         }
         if ( vStepInfo[i].vPaths[j].bOutStart  &&  ! m_bOpenOutRaw) {
           // se richiesto, controllo di essere davvero fuori dal grezzo [controllo basilare, migliorabile]
            Point3d ptStart ; vCrvPaths[j]->GetStartPoint( ptStart) ;
            double dElev ;
            PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
            pCrvArc->Set( ptStart, m_vtTool, 50. * EPS_SMALL) ;
            PtrOwner<ISurfFlatRegion> pSfrCheck( CreateSurfFlatRegion()) ;
            if ( IsNull( pSfrCheck)  ||  ! pSfrCheck->AddExtLoop( Release( pCrvArc)))
               return false ;
            if ( CalcRegionElevation( pSfrCheck, m_vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)  &&
                  dElev > EPS_SMALL) {
               vStepInfo[i].vPaths[j].bOutStart = false ;
               delete( vCrvPaths[j]->RemoveFirstOrLastCurve( false)) ;
            }
         }
        // controllo se il percorso ha un'uscita presso un lato aperto
          vStepInfo[i].vPaths[j].bOutEnd = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                             vCrvPaths[j]->GetLastCurve()->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 caso ottimizzato a spirale
         vStepInfo[i].vPaths[j].bOptCirle = ( vCrvPaths[j]->GetCurveCount() > 0  &&
                                              vCrvPaths[j]->GetTempProp( 0) == TEMP_PROP_OPT_CIRCLE) ;

        // 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) ;
        // assegno il percorso
         if ( ! vStepInfo[i].vPaths[j].pCrvPath.Set( vCrvPaths[j]))
            return false ;
      }
     // definisco il nuovo punto di riferimento per il percorso successivo
     // Se caso ottimizzato a spirale
      if ( int( vStepInfo[i].vPaths.size()) == 1  &&  vStepInfo[i].vPaths[0].bOptCirle) {
        // Se entrata da fuori, ricomincio dall'esterno
         if ( vStepInfo[i].vPaths[0].bOutStart)
            vStepInfo[i].vPaths[0].pCrvPath->GetStartPoint( ptStartRef) ;
        // altrimenti
         else {
            if ( m_Params.m_nSubType == POCKET_SPIRALOUT)
               vStepInfo[i].vPaths[0].pCrvPath->GetEndPoint( ptStartRef) ; // è invertito
            else
               vStepInfo[i].vPaths[0].pCrvPath->GetStartPoint( ptStartRef) ;
         }
      }
     // altrimenti rimane fisso al punto iniziale del percorso precedente
      else
         vStepInfo[i].vPaths.front().pCrvPath->GetStartPoint( ptStartRef) ;
     // aggiorno la progressBar
      ExeProcessEvents( 50 + i * 50 / int( vStepInfo.size()), 0) ;
   }

  // controllo se la svuotatura è riferita ad un foro chiuso
   bool bHolePocketing = true ;
   for ( int i = 0 ; i < int( vStepInfo.size())  &&  bHolePocketing ; ++ i) {
      bHolePocketing = ( int( vStepInfo[i].vPaths.size()) == 1  &&
                         vStepInfo[i].vPaths[0].bOptCirle  &&
                         ! vStepInfo[i].vPaths[0].bOutStart  &&
                         ! vStepInfo[i].vPaths[0].bOutEnd) ;
   }
  // se foro chiuso ed entrata ad elica, aggiusto il raggio massimo
   if ( bHolePocketing  &&  m_Params.m_nSubType == POCKET_SUB_SPIRALOUT  &&  GetLeadInType() == POCKET_LI_HELIX) {
      for ( const StepInfoPO& currStep : vStepInfo) {
         if ( currStep.pSfrPock != nullptr  &&  currStep.pSfrPock->IsValid()) {
            double dRad = 0. ;
            currStep.pSfrPock->GetMaxOffset( dRad) ;
            m_dMaxHelixRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), dRad - ( m_TParams.m_dDiam / 2. + GetOffsR())) ; ;
            break ;
         }
      }
   }
   
  // calcolo la curva di ritorno ( se necessaria)
   for ( int i = 0 ; i < int( vStepInfo.size()) ; ++ i) {
      for ( int j = 0 ; j < int( vStepInfo[i].vPaths.size()) ; ++ j) {
         if ( GetLeadInType() == POCKET_LI_GLIDE  ||  bHolePocketing) {
            PtrOwner<ICurveComposite> pCrvGlideIn( CreateCurveComposite()) ;
            if ( IsNull( pCrvGlideIn)  ||
                 ! CalcRetCurve( vStepInfo[i].vPaths[j], vStepInfo[i], vStepInfo[i].vPaths[j].pCrvPath,
                                 vStepInfo[i].pSfrPock->GetNormVersor(), bHolePocketing, true, pCrvGlideIn)) {
               m_pMchMgr->SetLastError( 2415, "Error in PocketingNT : LeadIn not computable") ;
               return false ;
            }
            if ( ! IsNull( pCrvGlideIn)  &&  pCrvGlideIn->IsValid())
               if ( ! vStepInfo[i].vPaths[j].pCrvGlideIn.Set( Release( pCrvGlideIn)))
                  return false ;
         }
        // se uscita a scivolo
         if ( GetLeadOutType() == POCKET_LO_GLIDE  ||  bHolePocketing) {
            PtrOwner<ICurveComposite> pCrvGlideOut( CreateCurveComposite()) ;
            if ( IsNull( pCrvGlideOut)  ||
                 ! CalcRetCurve( vStepInfo[i].vPaths[j], vStepInfo[i], vStepInfo[i].vPaths[j].pCrvPath,
                                 vStepInfo[i].pSfrPock->GetNormVersor(), bHolePocketing, false, pCrvGlideOut)) {
               m_pMchMgr->SetLastError( 2416, "Error in PocketingNT : LeadOut not computable") ;
               return false ;
            }
            if ( ! IsNull( pCrvGlideOut)  &&  pCrvGlideOut->IsValid())
               if ( ! vStepInfo[i].vPaths[j].pCrvGlideOut.Set( Release( pCrvGlideOut)))
                  return false ;
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::ManageSmoothLink( const PathInfoPO& currPath, const PathInfoPO& nextPath, bool bSamePlane, 
                               bool& bSmoothEnd, bool& bForceLinear)
{
  // definizione smusso finale a seconda del tipo di lavorazioni
   bSmoothEnd = true ;
   bForceLinear = false ;
   switch ( m_Params.m_nSubType)
   {
   case POCKET_SUB_SPIRALIN :
   case POCKET_SUB_SPIRALOUT :
     // ... se devo scendere allo step successivo presso un lato aperto
      if ( ! bSamePlane  &&  nextPath.bOutStart) {
        // ... non smusso il percorso finale
         bSmoothEnd = false ;
         return true ;
      }
   break ;
   case POCKET_SUB_ZIGZAG :
   case POCKET_SUB_ONEWAY :
     // ... se sono sullo stesso piano e passo da un tratto finale aperto ad un tratto iniziale aperto...
      if ( bSamePlane  &&  currPath.bOutEnd  && nextPath.bOutStart) {
        // .. smusso sia inizio che fine
         return true ;
      }
      bForceLinear = true ;
   break ;
   case POCKET_SUB_CONFORMAL_ONEWAY :
   case POCKET_SUB_CONFORMAL_ZIGZAG :
     // ... se devo scendere allo step successivo presso un lato aperto
      if ( ! bSamePlane  &&  nextPath.bOutStart) {
        // ... non smusso il percorso finale
         bSmoothEnd = false ;
         return true ;
      }
   break ;
   default:
      break ;
   }
   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 ;
   #if DEBUG_FEED
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nGrp, "Feed") ;
   #endif

  // 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 = 0. ;
  // 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.pCrvGlideIn, 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) ;
               double dEscapeElev = 0. ;
               Vector3d vtEscape ;
               if ( bAbsFirst)
                  CalcFirstElevation( ptStart, ptP1, vtTool, currStep, dSafeZ, dStep, dCurrElev, dEscapeElev, vtEscape) ;
               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) ;
               }
              // approccio al punto iniziale ( se punti non allineati lungo vtTool)
               double dMySafeZ = ( bAbsFirst ? dSafeZ : 0.) ;
               Point3d ptMyPos ; GetCurrPos( ptMyPos) ;
               double dMyElev = ( bAbsFirst ? dCurrElev : ( ptMyPos - ptP1) * vtTool) ;
               double dMyAppr = ( bAbsFirst ? dAppr : 0.) ;
               if ( bAbsFirst  ||  ! OrthoCompo( ptMyPos - ptP1, vtTool).IsSmall()) {
                  if ( bAbsFirst  &&  dEscapeElev > 10 * EPS_SMALL  &&  vtEscape.SqLen() > 100 * EPS_SMALL) {
                     if ( ! AddApproach( ptP1 + vtEscape * dEscapeElev, vtEscape, dMySafeZ, dSafeAggrBottZ, 0, dMyAppr, bSplitArcs, currPath.bOutStart)) {
                        m_pMchMgr->SetLastError( 3011, "Error in PocketingNT : Approach not computable") ;
                        return false ;
                     }
                  }
                  else {
                     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()) ;
               Point3d ptCurr ; GetCurrPos( ptCurr) ;
               if ( ! AreSamePointApprox( ptP1, ptCurr))
                  AddLinearMove( ptP1) ;
               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, Get( currPath.pCrvGlideIn),
                                 ( 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
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               Point3d ptP3 = pLine->GetEnd() ;
               Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
               SetFeed( dCoeffFeed * GetRightFeed( vtMove, vtTool)) ;
               #if DEBUG_FEED
                  DebugDrawFeed( pCurve->Clone(), dCoeffFeed * GetRightFeed( vtMove, vtTool), nLay) ;
               #endif
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
            else {
               SetFeed( dCoeffFeed * GetFeed()) ;
               #if DEBUG_FEED
                  DebugDrawFeed( pCurve->Clone(), dCoeffFeed * GetFeed(), nLay) ;
               #endif
               if ( AddCurveMove( pCurve, bSplitArcs) == 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, currStep.pSfrPock, currPath.pCrvGlideOut, bSplitArcs, false, ptP1)) {
                     m_pMchMgr->SetLastError( 3014, "Error in PocketingNT : LeadOut not computable") ;
                     return false ;
                  }
                 // calcolo l'elevazione al di sopra del punto corrente
                  double dLastElev = 0., dEscapeElev = 0. ;
                  Vector3d vtEscape ;
                  if ( ! CalcLastElevation( ptEnd, ptP1, vtTool, currStep, dSafeZ, dStep, dLastElev, dEscapeElev, vtEscape))
                     return false ;
                  if ( dEscapeElev > 10 * EPS_SMALL  &&  vtEscape.SqLen() > 100 * EPS_SMALL) {
                     AddLinearMove( ptP1 + vtTool * dLastElev) ;
                     if ( ! AddRetract( ptP1 + vtTool * dLastElev, vtEscape, dSafeZ, dSafeAggrBottZ, dEscapeElev, dAppr, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 3015, "Error in PocketingNT : Retract not computable") ;
                        return false ;
                     }
                  }
                  else {
                    // aggiungo retroazione finale
                     if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dLastElev, 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) ;
                  const PathInfoPO& PathToGo = ( bSamePlane ? currStep.vPaths[j+1] :
                                                              vStepInfo[i+1].vPaths.front()) ;
                  Point3d ptDest ; Vector3d vtDest ;
                 // se entrata a scivolo ammissibile, allora la destinazione è l'inizio dello scivolo (nel piano)
                  if ( GetLeadInType() == POCKET_LI_GLIDE  &&  ( PathToGo.pCrvGlideIn != nullptr  &&
                                                                 PathToGo.pCrvGlideIn->IsValid())) {
                     PathToGo.pCrvGlideIn->GetStartPoint( ptDest) ;
                     PathToGo.pCrvGlideIn->GetStartDir( vtDest) ;
                  }
                 // altrimenti è l'inizio del percorso
                  else {
                     PathToGo.pCrvPath->GetStartPoint( ptDest) ;
                     PathToGo.pCrvPath->GetStartDir( vtDest) ;
                  }
                 // determino se un collegamento tra i punti proiettati nel piano attuale è ammissibile
                  bool bSafeLimit = false ;
                  bool bSmoothEnd = true ;
                  bool bForceLinear = false ;
                  ManageSmoothLink( currPath, PathToGo, bSamePlane, bSmoothEnd, bForceLinear) ;
                  PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
                  if ( IsNull( pCrvLink))
                     return false ;
                 // se ho una curva di ritorno, allora uso quella
                  if ( currPath.pCrvRet != nullptr  &&  currPath.pCrvRet->IsValid()) {
                     pCrvLink->CopyFrom( currPath.pCrvRet) ;
                     bSafeLimit = true ;
                  }
                 // altrimenti cerco raccordo smussato
                  else {
                     if ( ! bForceLinear) {
                        if ( ! CheckSafetyLink( ptEnd, vtEnd, ptDest, vtDest, currStep.pSfrLimit, vtTool,
                                                bSmoothEnd, bSafeLimit, pCrvLink))
                           return false ;
                     }
                  }
                 // determino l'elevazione sul punto corrente e sul punto di destinazione
                  dCurrElev = 0. ;
                  double dNextElev = 0. ;
                 // se il collegamento non rovina il grezzo...
                  if ( bSafeLimit) {
                     if ( bSamePlane) {
                       // ... ed è sullo stesso piano di svuotatura
                        if ( ( ( m_Params.m_nSubType == POCKET_SUB_SPIRALIN  ||  m_Params.m_nSubType == POCKET_SUB_SPIRALOUT) &&
                               ! vStepInfo[i].vPaths[j+1].bOutStart)  ||
                             ( m_Params.m_nSubType != POCKET_SUB_SPIRALIN  &&  m_Params.m_nSubType != POCKET_SUB_SPIRALOUT  &&
                               m_Params.m_nSubType != POCKET_CONFORMAL_ZIGZAG  &&   m_Params.m_nSubType != POCKET_SUB_CONFORMAL_ONEWAY)) {
                           dCurrElev -= currStep.dRelativeDepth ;
                           dNextElev = dCurrElev ;
                        }
                     }
                     else {
                       // ... ed è al piano di svuotatura sottostante
                        dNextElev += ( ptEnd - ptDest) * vtTool ;
                     }
                  }
                 // se il collegamento rovina il grezzo
                  else {
                     dCurrElev -= currStep.dDepth ;
                     dNextElev -= ( bSamePlane ? currStep.dDepth : vStepInfo[i+1].dDepth) ;
                  }
                 // End Feed
                  SetFeed( GetEndFeed()) ;
                 // per non passare a filo dello step precedente ( quindi nel caso si isole a filo delle stesse)
                 // aggiungo una elevazione extra nel caso di violazione della regione limite
                  dCurrElev += ( bSafeLimit ? 0. : EXTRA_ELEV) ;
                  dNextElev += ( bSafeLimit ? 0. : EXTRA_ELEV) ;
                 // se devo salire lungo vtTool da vtEnd, mi alzo
                  if ( dCurrElev > EPS_SMALL)
                     AddLinearMove( ptEnd + dCurrElev * vtTool, bSplitArcs) ;
                 // mi dirigo sopra a ptDest
                  Point3d ptCheck ;
                  if ( GetCurrPos( ptCheck)  &&  ! AreSamePointApprox( ptCheck, ptDest + dNextElev * vtTool)) {
                     if ( pCrvLink->IsValid()) {
                        pCrvLink->Translate( dCurrElev * vtTool) ;
                        AddCurveMove( pCrvLink, bSplitArcs) ;
                     }
                     else
                        AddLinearMove( ptDest + dNextElev * vtTool, bSplitArcs) ;
                  }
                 // aggiorno le elevazioni
                  dCurrElev = dNextElev ;
               }
            }
         }
      }
   }

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

//----------------------------------------------------------------------------
bool
PocketingNT::CalcFirstElevation( const Point3d& ptStart, const Point3d& ptP1, const Vector3d& vtTool,
                                 const StepInfoPO& currStep, double dSafeZ, double dStep, double& dCurrElev,
                                 double& dEscapeElev, Vector3d& vtEscape) const
{
  // elevazione per ingresso
   if ( ! GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dCurrElev))
      dCurrElev = - currStep.dDepth + 10 * EPS_SMALL ;
   else
      dCurrElev = max( dCurrElev, - currStep.dDepth + 10 * EPS_SMALL) ;
   dEscapeElev = 0 ;
   vtEscape = V_NULL ;
   double dMyEscapeEvel = 0 ;
   Vector3d vtMyEscape = vtTool ;
   vtMyEscape.z = ( m_bAboveHead ? max( vtTool.z, 0.) : min( vtTool.z, 0.)) ;
   bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                      GetAhPointUnderRaw( ptP1 + dCurrElev * vtTool, vtTool, 0, GetRadiusForStartEndElevation(),
                                          m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeEvel) ;
   bool bUhAboveRaw = ! m_bAboveHead  &&
                      GetUhPointAboveRaw( ptP1 + dCurrElev * vtTool, vtTool, 0, GetRadiusForStartEndElevation(),
                                          m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeEvel) ;
   if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab) {
      dEscapeElev = dMyEscapeEvel ;
      vtEscape = vtMyEscape ;
      vtEscape.Normalize() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
PocketingNT::CalcLastElevation( const Point3d& ptEnd, const Point3d& ptP1, const Vector3d& vtTool, const StepInfoPO& currStep,
                                double dSafeZ, double dStep, double& dCurrElev, double& dEscapeElev, Vector3d& vtEscape) const
{
  // elevazione per uscita
   if ( ! GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), m_TParams.m_dLen, vtTool, dCurrElev))
      dCurrElev = - currStep.dDepth ;
   dEscapeElev = 0 ;
   vtEscape = V_NULL ;
   double dMyEscapeEvel = 0 ;
   Vector3d vtMyEscape = vtTool ;
   vtMyEscape.z = ( m_bAboveHead ? max( vtTool.z, 0.) : min( vtTool.z, 0.)) ;
   bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                      GetAhPointUnderRaw( ptP1 + vtTool * dCurrElev, vtTool, 0, GetRadiusForStartEndElevation(),
                                          m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeEvel) ;
   bool bUhAboveRaw = ! m_bAboveHead  &&
                      GetUhPointAboveRaw( ptP1 + vtTool * dCurrElev, vtTool, 0, GetRadiusForStartEndElevation(),
                                          m_TParams.m_dLen, false, dSafeZ, vtMyEscape, dMyEscapeEvel) ;
   if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab) {
      dEscapeElev = dMyEscapeEvel ;
      vtEscape = vtMyEscape ;
      vtEscape.Normalize() ;
   }
   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)) ;
}

//------------------------------------------------------------------
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( 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 :
      {
         if ( ! pRCrv->GetStartPoint( ptP1))
            return false ;
         ptP1 += vtTool * ( vtTool * ( ptStart - ptP1)) ;
         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( CloneCurveComposite( pRCrv)) ;
         if ( IsNull( pCrv)  ||  ! pCrv->IsValid())
            return false ;
         pCrv->SetExtrusion( vtN) ;
        // la porto alla giusta quota
         Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
        // 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 ISurfFlatRegion* pSfr, 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( CloneCurveComposite( pRCrv)) ;
         if ( IsNull( pCrv)  ||  ! pCrv->IsValid())
            return false ;
         pCrv->SetExtrusion( vtN) ;
        // controllo se ammissibile
         if ( VerifyLeadInOutGlide( pSfr, pCrv)) {
           // recupero le quote per la curva
            Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
            Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
            ptFin += vtN * 1.0 ;
            double dNini = ( ptIni - ORIG) * vtN ;
            double dNfin = ( ptFin - ORIG) * vtN ;
            AdjustCurveSlope( pCrv, dNini, dNfin) ;
           // emetto (con eventuale spezzatura)
            if ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
            ptP1 = ptFin ;
         }
         else {
           // nessuna uscita
            ptP1 = ptEnd ;
         }
         return true ;
      }
   default :
      return false ;
   }
}

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

//----------------------------------------------------------------------------
bool
PocketingNT::GetForcedClosed( void)
{
   double dOpenLen ;
   return ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, dOpenLen)  &&  dOpenLen < EPS_ZERO) ;
}

//----------------------------------------------------------------------------
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::CheckSafetyLink( const Point3d& ptCurr, const Vector3d& vtCurr,
                              const Point3d& ptDest, const Vector3d& vtDest,
                              const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
                              bool bSmoothEnd, bool& bSafeLimit, ICurveComposite* pCrvSafeLink)
{
  // controllo dei parametri
   if ( ! ptCurr.IsValid()  ||  ! ptDest.IsValid()  ||  ! vtCurr.IsValid()  ||  ! vtDest.IsValid())
      return false ;
   pCrvSafeLink->Clear() ;
   bSafeLimit = true ;

  // porto ptDest alla stessa quota di ptCurr secondo vtTool
   Plane3d plProj ;
   if ( ! plProj.Set( ptCurr, vtTool))
      return false ;
   Point3d ptDestProj = ProjectPointOnPlane( ptDest, plProj) ;
  // se coicidenti allora non devo creare alcun link
   if ( AreSamePointApprox( ptCurr, ptDestProj))
      return true ;

  // definisco frame locale ( intersezioni nel piano XY)
   Frame3d frLoc ;
   if ( ! frLoc.Set( ptCurr, vtTool))
      return false ;

  // porto i punti nel piano locale
   Point3d ptS = ORIG ;
   Point3d ptE = GetToLoc( ptDestProj, frLoc) ;
   Vector3d vtS = GetToLoc( vtCurr, frLoc) ;
   Vector3d vtE = GetToLoc( vtDest, frLoc) ;

  // ----------------------------- definisco il collegamento -----------------------------
   PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
   if ( IsNull( pCrvLink))
      return false ;
   bool bLinkLinear = ( ! pCrvLink->AddPoint( ptS)  ||
                        ! pCrvLink->AddLine( ptS + ( m_TParams.m_dDiam / 4.) * vtS)) ;
   if ( bSmoothEnd) {
     // ZigZag tra ptS e ptE mediante vtS e - vtE
      bLinkLinear = ( bLinkLinear  ||
                      ! pCrvLink->AddLine( ptE - ( m_TParams.m_dDiam / 4.) * vtE)  ||
                      ! pCrvLink->AddLine( ptE)  ||
                      ( ! pCrvLink->IsValid()  &&  pCrvLink->GetCurveCount() == 3)) ;
   }
   else {
     // evito tratto ZigZag finale
      bLinkLinear = ( bLinkLinear  ||
                      ! pCrvLink->AddLine( ptE)  ||
                      ( ! pCrvLink->IsValid()  &&  pCrvLink->GetCurveCount() == 2)) ;
   }
   if ( ! bLinkLinear) {
      SelfIntersCurve SIC( *pCrvLink) ;
      bLinkLinear = ( SIC.GetCrossOrOverlapIntersCount() > 0) ;
   }
   if ( bLinkLinear) {
      pCrvLink->Clear() ;
      pCrvLink->AddPoint( ptS) ;
      pCrvLink->AddLine( ptE) ;
      if ( ! pCrvLink->IsValid())
         return false ;
   }
   else {
     // controllo variazioni angolari delle curve
      Vector3d vtStart ; pCrvLink->GetCurve( 0)->GetStartDir( vtStart) ;
      Vector3d vtMid ; pCrvLink->GetCurve( 1)->GetStartDir( vtMid) ;
      Vector3d vtEnd ;
      if ( bSmoothEnd)
         pCrvLink->GetCurve( 2)->GetStartDir( vtEnd) ;
      if ( vtStart * vtMid < SAFETY_LINK_COS) {
         if ( bSmoothEnd) {
            delete( pCrvLink->RemoveFirstOrLastCurve( false)) ;
            delete( pCrvLink->RemoveFirstOrLastCurve( false)) ;
            pCrvLink->AddLine( ptS, false) ;
            pCrvLink->GetStartDir( vtMid) ;
         }
         else
           pCrvLink->Clear() ;
      }
      if ( bSmoothEnd) {
         if ( vtEnd * vtMid < SAFETY_LINK_COS) {
            delete( pCrvLink->RemoveFirstOrLastCurve( true)) ;
            delete( pCrvLink->RemoveFirstOrLastCurve( true)) ;
            if ( ! pCrvLink->IsValid())
               pCrvLink->AddPoint( ptS) ;
            pCrvLink->AddLine( ptE) ;
         }
      }
      if ( ! pCrvLink->IsValid()) {
         pCrvLink->Clear() ;
         pCrvLink->AddPoint( ptS) ;
         pCrvLink->AddLine( ptE) ;
         if ( ! pCrvLink->IsValid())
            return false ;
      }
   }
   #if DEBUG_SAFETY_LINK
      int nGrp = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
      int nLay = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrp, GLOB_FRM) ;
      m_pGeomDB->SetName( nLay, "Safety_Link") ;
      m_pGeomDB->SetStatus( nGrp, GDB_ST_OFF) ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
      m_pGeomDB->SetMaterial( _a, LIME) ;
   #endif

  // Smusso il Link secondo i parametri richiesti
   CalcSmoothCurve( pCrvLink, m_TParams.m_dDiam / 8., m_TParams.m_dDiam / 8., false) ;
   #if DEBUG_SAFETY_LINK
      _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
      m_pGeomDB->SetMaterial( _a, RED) ;
   #endif

  // controllo eventuale interferenza con la regione limite
   PtrOwner<ISurfFlatRegion> pSfrLimitLoc( CreateSurfFlatRegion()) ;
   if ( IsNull( pSfrLimitLoc))
      return false ;
   if ( pSfrLimit != nullptr  &&  pSfrLimit->IsValid()) {
      pSfrLimitLoc.Set( CloneSurfFlatRegion( pSfrLimit)) ;
      if ( IsNull( pSfrLimitLoc)  ||  ! pSfrLimitLoc->IsValid()  ||
           ! pSfrLimitLoc->ToLoc( frLoc)  ||
           ! pSfrLimitLoc->Offset( m_TParams.m_dDiam / 2. + GetOffsR() - 10 * EPS_SMALL, ICurve::OFF_FILLET))
         return false ;
      #if DEBUG_SAFETY_LINK
         _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pSfrLimitLoc->Clone()) ;
         m_pGeomDB->SetMaterial( _a, Color( .5, .5, .5, .35)) ;
      #endif
      for ( int nC = 0 ; nC < pSfrLimitLoc->GetChunkCount()  &&  bSafeLimit ; ++ nC) {
         CRVCVECTOR ccClass ;
         bSafeLimit = ( pSfrLimitLoc->GetCurveClassification( *pCrvLink, EPS_SMALL, ccClass)  &&
                        int( ccClass.size()) == 1  &&  ccClass[0].nClass == CRVC_OUT) ;
      }
   }

  // se Link smussato ammissibile
   if ( bSafeLimit) {
      pCrvSafeLink->CopyFrom( pCrvLink) ;
      pCrvSafeLink->ToGlob( frLoc) ;
      return true ;
   }
  // se interferenza con la regione limite, allora provo con link lineare
   else if ( ! IsNull( pSfrLimitLoc)  &&  pSfrLimitLoc->IsValid()) {
      pCrvLink->Clear() ;
      pCrvLink->AddPoint( ptS) ;
      pCrvLink->AddLine( ptE) ;
      if ( ! pCrvLink->IsValid())
         return false ;
      #if DEBUG_SAFETY_LINK
         _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrvLink->Clone()) ;
         m_pGeomDB->SetMaterial( _a, YELLOW) ;
      #endif
      bSafeLimit = true ;
      for ( int nC = 0 ; nC < pSfrLimitLoc->GetChunkCount()  &&  bSafeLimit ; ++ nC) {
         CRVCVECTOR ccClass ;
         bSafeLimit = ( pSfrLimitLoc->GetCurveClassification( *pCrvLink, EPS_SMALL, ccClass)  &&
                        int( ccClass.size()) == 1  &&  ccClass[0].nClass == CRVC_OUT) ;
      }
   }
   if ( bSafeLimit) {
      pCrvSafeLink->CopyFrom( pCrvLink) ;
      pCrvSafeLink->ToGlob( frLoc) ;
   }

   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 - GetOffsR() - 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 - GetOffsR() + 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::VerifyLeadInOutGlide( const ISurfFlatRegion* pSfr, ICurveComposite* pCrvGlide)
{
  // controllo validità dei parametri
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return false ;
  // Offset della regione
   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfr->CreateOffsetSurf( - m_TParams.m_dDiam / 2 - GetOffsR() + 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
   if ( IsNull( pSfrOffs)  ||  ! pSfrOffs->IsValid())
      return false ;
  // controllo se la curva interseca la regione
   CRVCVECTOR ccClass ;
   if ( ! pSfrOffs->GetCurveClassification( *pCrvGlide, EPS_SMALL, ccClass))
      return false ;
   if ( int( ccClass.size()) == 1  &&  ccClass[0].nClass == CRVC_IN)
      return true ;
  // recupero il primo tratto In e Limito la curva a tale tratto
   if ( ccClass[0].nClass != CRVC_IN)
      return false ;
   PtrOwner<ICurve> pCrvGlideInside( pCrvGlide->CopyParamRange( ccClass[0].dParS, ccClass[0].dParE)) ;
   if ( IsNull( pCrvGlideInside)  ||  ! pCrvGlideInside->IsValid())
      return false ;
   return ( pCrvGlide->Clear()  &&  pCrvGlide->AddCurve( Release( pCrvGlideInside))) ;
}

//----------------------------------------------------------------------------
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::DebugDrawSfr( const ISurfFlatRegion* pSfr, bool bUniform, int nLayer)
{
   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
      return ;

   int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, 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))) ;
         DebugDrawLoop( pCrvCompo->Clone(), nLayer, bUniform) ;
      }
   }

   return ;
}

//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawLoop( const ICurveComposite* pCrvCompo, int nLayer, 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, nLayer, pCrvCompo->GetCurve( nU)->Clone()) ;
      m_pGeomDB->SetMaterial( nInd, bUniform ? WHITE : ( nProp0 == 0 ? BLUE : RED)) ;
   }

   return  ;
}

//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawBox( const BBox3d& BBox, const Frame3d& FrBox, int nLayer)
{
   Point3d ptMin = BBox.GetMin() ; ptMin.ToGlob( FrBox) ;
   Point3d ptMax = BBox.GetMax() ; ptMax.ToGlob( FrBox) ;
   PtrOwner<ICurveComposite> pBase( CreateCurveComposite()) ;
   pBase->AddPoint( ptMin) ;
   Vector3d vtPtNext = ( ptMin - ORIG) + BBox.GetDimX() * FrBox.VersX() ;
   pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
   vtPtNext = ( ptMax - ORIG) - BBox.GetDimZ() * FrBox.VersZ() ;
   pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
   vtPtNext = ( ptMin - ORIG) + BBox.GetDimY() * FrBox.VersY() ;
   pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
   pBase->Close() ;
   int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   pBase->Translate( BBox.GetDimZ() * FrBox.VersZ()) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   pBase->Clear() ;
   pBase->AddPoint( ptMin) ;
   vtPtNext = ( ptMin - ORIG) + BBox.GetDimZ() * FrBox.VersZ() ;
   pBase->AddLine( Point3d( vtPtNext.x, vtPtNext.y, vtPtNext.z)) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   pBase->Translate( BBox.GetDimX() * FrBox.VersX()) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   pBase->Translate( BBox.GetDimY() * FrBox.VersY()) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   pBase->Translate( - BBox.GetDimX() * FrBox.VersX()) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, pBase->Clone()) ;
   m_pGeomDB->SetMaterial( _a, YELLOW) ;
   PtrOwner<IGeoFrame3d> fr( CreateGeoFrame3d()) ;
   fr->Set( FrBox) ;
   _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayer, fr->Clone()) ;
}

//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawOpenEdgesInRaw( const ICRVCOMPOPOVECTOR& vpCrvs, int nlayer)
{
   for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
      Color myColor = BLACK ;
      if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_CLOSE_EDGE)
         myColor = BLUE ;
      else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE)
         myColor = RED ;
      else if ( vpCrvs[i]->GetTempProp( 0) == TEMP_PROP_OPEN_EDGE_IN_RAW)
         myColor = ORANGE ;
      int _a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nlayer, vpCrvs[i]->Clone()) ;
      m_pGeomDB->SetMaterial( _a, myColor) ;
   }
}

//----------------------------------------------------------------------------
void
PocketingNT::DebugDrawFeed( const ICurve* pCrv, double dFeed, int nLay)
{
   if ( pCrv == nullptr  ||  ! pCrv->IsValid())
      return ;

   double dMinFeed = GetFeed() * GetSideStep() / m_TParams.m_dDiam ;
   double myAngle = 120 * ( ( ( dFeed - dMinFeed) / ( GetFeed() - dMinFeed))) ;
   int nInd = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLay, pCrv->Clone()) ;
   m_pGeomDB->SetMaterial( nInd, GetColorFromHSV( HSV( myAngle, 1., 1.))) ;
   return ;
}