//----------------------------------------------------------------------------
//  EgalTech 2017-2023
//----------------------------------------------------------------------------
// File : Pocketing.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 "Pocketing.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/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 <algorithm>

using namespace std ;

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

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

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

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

//----------------------------------------------------------------------------
Pocketing*
Pocketing::Clone( void) const
{
  // alloco oggetto
   Pocketing* pPock = new(nothrow) Pocketing ;
  // 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
Pocketing::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
Pocketing::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
Pocketing::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 ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Pocketing::Pocketing( void)
{
   m_Params.m_sName = "*" ;
   m_Params.m_sToolName = "*" ;
   m_TParams.m_sName = "*" ;
   m_TParams.m_sHead = "*" ;
   m_dTHoldBase = 0 ;
   m_dTHoldLen = 0 ;
   m_dTHoldDiam = 0 ;
   m_dMaxHelixRad = INFINITO ;
   m_nStatus = MCH_ST_TO_VERIFY ;
   m_nPockets = 0 ;
   m_bTiltingTab = false ;
   m_bAboveHead = true ;
   m_bAggrBottom = false ;
   m_bOpenOutRaw = false ;
   m_dOpenMinSafe = 0 ;
}

//----------------------------------------------------------------------------
bool
Pocketing::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
Pocketing::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
Pocketing::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
Pocketing::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
Pocketing::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
Pocketing::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 Pocketing : 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
Pocketing::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 Pocketing : 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 Pocketing : 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 Pocketing : 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 catena
   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
Pocketing::Apply( bool bRecalc, bool bPostApply)
{
  // reset numero percorsi di svuotatura generati
   int nCurrPockets = m_nPockets ;
   m_nPockets = 0 ;

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

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

  // aggiorno dati geometrici dell'utensile
   if ( ! UpdateToolData()) {
      m_pMchMgr->SetLastError( 2401, "Error in Pocketing : 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( "Pocketing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
      LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ;
     // eseguo aggiornamento assi macchina e collegamento con operazione precedente
      if ( ! Update( bPostApply))
         return false ;
      m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
      LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
     // esco con successo
      return true ;
   }
   m_nStatus = MCH_ST_TO_VERIFY ;

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

  // rendo corrente l'utensile usato nella lavorazione
   if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
      m_pMchMgr->SetLastError( 2428, "Error in Pocketing : 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 Pocketing : 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 Pocketing : 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(), "Pocketing apply done") ;

   return true ;
}

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

  // se lavorazione vuota, esco
   if ( m_nPockets == 0) {
      m_pMchMgr->SetWarning( 2452, "Warning in Pocketing : 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 Pocketing : axes values not calculable") ;
      else
         m_pMchMgr->SetLastError( 2424, "Error in Pocketing : 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 sDblTcPos ; string sDblHead ; int nDblExit ;
      bool bOk = GetDoubleToolData( sDblTool, sDblTcPos, 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 Pocketing : axes values not calculable for double") ;
            else
               m_pMchMgr->SetLastError( 2424, "Error in Pocketing : 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( 2433, sSpecErr) ;
      else
         m_pMchMgr->SetLastError( 2433, "Error in Pocketing : 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 Pocketing : link movements not calculable") ;
      else
         m_pMchMgr->SetLastError( 2426, "Error in Pocketing : 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 Pocketing : post apply not calculable") ;
      return false ;
   }

   return true ;
}

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

//----------------------------------------------------------------------------
bool
Pocketing::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 Pocketing : 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 Pocketing : 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
Pocketing::GetGeometry( SELVECTOR& vIds) const
{
  // restituisco l'elenco delle entità
   vIds = m_vId ;
   return true ;
}

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

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

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

//----------------------------------------------------------------------------
bool
Pocketing::Chain( int nGrpDestId)
{
  // vettore puntatori alle curve
   ICURVEPOVECTOR vpCrvs ;
   vpCrvs.reserve( m_vId.size()) ;
  // vettore selettori delle curve originali
   SELVECTOR vInds ;
  // recupero tutte le curve e le porto in globale
   for ( const auto& Id : m_vId) {
     // prendo le curve
      ICURVEPLIST lstPC ;
      if ( ! GetCurves( Id, lstPC)) {
         string sInfo = "Warning in Pocketing : 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
   int nCount = 0 ;
   INTVECTOR vnId2 ;
   while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
     // creo una curva composita
      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
      if ( IsNull( pCrvCompo))
         return false ;
     // estrusione e spessore
      Vector3d vtExtr = Z_AX ;
      double dThick = 0 ;
     // vettore Id originali
      SELVECTOR vId2 ;
      vId2.reserve( vnId2.size()) ;
     // recupero le curve semplici e le inserisco nella curva composita
      for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
         int nId = abs( vnId2[i]) - 1 ;
         bool bInvert = ( vnId2[i] < 0) ;
         vId2.emplace_back( vInds[nId]) ;
        // recupero la curva
         ICurve* pCrv = vpCrvs[nId] ;
        // se necessario, la inverto
         if ( bInvert)
            pCrv->Invert() ;
        // recupero eventuali estrusione e spessore
         Vector3d vtTemp ;
         if ( pCrv->GetExtrusion( vtTemp)) {
            vtExtr = vtTemp ;
            double dTemp ;
            if ( pCrv->GetThickness( dTemp)  &&  abs( dTemp) > abs( dThick))
               dThick = dTemp ;
         }
        // la aggiungo alla curva composta
         if ( ! pCrvCompo->AddCurve( ::Release( vpCrvs[nId]), true, dToler))
            return false ;
      }
     // se non sono state inserite curve, vado oltre
      if ( pCrvCompo->GetCurveCount() == 0)
         continue ;
     // imposto estrusione e spessore
      pCrvCompo->SetExtrusion( vtExtr) ;
      pCrvCompo->SetThickness( dThick) ;
     // aggiorno il nuovo punto vicino
      pCrvCompo->GetEndPoint( ptNear) ; 
     // se utile, approssimo con archi
      if ( ! ApproxWithArcsIfUseful( pCrvCompo, true))
         return false ;
     // recupero eventuali lati aperti
      INTVECTOR vOpen ;
      for ( int i = 0 ; i < int( pCrvCompo->GetCurveCount()) ; ++ i) {
         int nProp = 0 ;
         if ( pCrvCompo->GetCurveTempProp( i, nProp)  &&  nProp == 1)
            vOpen.emplace_back( i) ;
      }
     // creo nuovo gruppo
      int nPathId = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDestId, Frame3d()) ;
      if ( nPathId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nCount)) ;
      m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vId2)) ;
     // inserisco la curva composita nel gruppo destinazione
      int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::Release( pCrvCompo)) ;
      if ( nNewId == GDB_ID_NULL)
         return false ;
     // salvo info con eventuali lati aperti
      if ( ! vOpen.empty())
         m_pGeomDB->SetInfo( nNewId, KEY_OPEN, vOpen) ;
   }
   return true ;
}

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

  // verifico sia una curva chiusa (deve delimitare l'area da svuotare)
   int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
   if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO)
      return false ;
   ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pCrv == nullptr  ||  ! pCrv->IsClosed()) {
      m_pMchMgr->SetLastError( 2402, "Error in Pocketing : Open Contour") ;
      return false ;
   }

  // copio la curva composita da elaborare
   int nCopyId = m_pGeomDB->CopyGlob( nCrvId, GDB_ID_NULL, nTempId) ;
   if ( nCopyId == GDB_ID_NULL)
      return false ;
   ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ;

  // annullo i flag di tratto aperto
   for ( int i = 0 ; i < int( pCompo->GetCurveCount()) ; ++ i)
      pCompo->SetCurveTempProp( i, 0) ;

  // verifico se vanno gestiti i lati aperti
   bool bSomeOpen ;
   SetCurveAllTempProp( nCrvId, GetForcedClosed(), pCompo, &bSomeOpen) ;

  // recupero estrusione e spessore
   Vector3d vtExtr = Z_AX ;
   pCompo->GetExtrusion( vtExtr) ;
   double dThick ;
   pCompo->GetThickness( dThick) ;

  // eventuale inversione direzione utensile
   if ( m_Params.m_bToolInvert) {
      vtExtr.Invert() ; 
      pCompo->SetExtrusion( vtExtr) ;
      dThick = - dThick ;
      pCompo->SetThickness( dThick) ;
   }

  // verifico sia piana e se necessario la appiattisco
   PtrOwner<ICurve> pFlatCrv( FlattenCurve( *pCompo, 50 * EPS_SMALL, 50 * EPS_ANG_SMALL, FLTCRV_USE_EXTR)) ;
   if ( IsNull( pFlatCrv)) {
      Plane3d plPlane ;
      if ( ! pCompo->IsFlat( plPlane, true, 50 * EPS_SMALL))
         m_pMchMgr->SetLastError( 2403, "Error in Pocketing : Contour Not Flat") ;
      else
         m_pMchMgr->SetLastError( 2404, "Error in Pocketing : Tool Not Perpendicular to Flat Area") ;
      return false ;
   }
   pFlatCrv->GetExtrusion( vtExtr) ;
   pCompo->Clear() ;
   pCompo->AddCurve( Release( pFlatCrv)) ;
   pCompo->SetExtrusion( vtExtr) ;
   pCompo->SetThickness( dThick) ;
  // sistemo senso antiorario visto dalla direzione di estrusione
   Plane3d plPlane ; double dArea ;
   pCompo->GetArea( plPlane, dArea) ;
   if ( plPlane.GetVersN() * vtExtr * dArea < 0)
      pCompo->Invert() ;

  // unisco le parti allineate (tranne inizio-fine se chiusa)
   if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false, true))
      return false ;

  // se ci sono lati aperti
   bool bMidOpen = false ;
   Point3d ptMidOpen ;
   Vector3d vtMidOut ;
   if ( bSomeOpen) {
     // ricerca del punto medio del lato aperto più lungo
      bMidOpen = GetMidOfLongestOpenSide( pCompo, ptMidOpen, vtMidOut) ;
     // sistemazioni per eventuali lati aperti
      if ( ! AdjustContourWithOpenEdges( pCompo)) {
         m_pMchMgr->SetLastError( 2430, "Error in Pocketing : adjust open edges failed") ;
         return false ;
      }
   }

  // sposto l'inizio a metà del tratto più lungo ( o aperto più lungo)
   if ( bMidOpen) {
      const double LEN_OUT = 5. + ( m_TParams.m_dDiam / 2.) ;
      double dPar ; int nFlag ;
      bMidOpen = ( DistPointCurve( ptMidOpen + LEN_OUT * vtMidOut, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlag) && pCompo->ChangeStartPoint( dPar)) ;
   }
   if ( ! bMidOpen)
      AdjustContourStart( pCompo) ;

  // recupero il punto di inizio (per poi salvarlo nelle info di CL path)
   Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;

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

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

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

  // verifico che il massimo materiale dell'utensile sia sensato
   const double MIN_MAXMAT = 1.0 ;
   if ( m_TParams.m_dMaxMat < dElev  &&  m_TParams.m_dMaxMat < MIN_MAXMAT) {
      string sInfo = "Error in Pocketing : 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 Pocketing : machining step (" + ToString( m_Params.m_dStep, 1) +
                     ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
      m_pMchMgr->SetWarning( 2457, sInfo) ;
   }
  // se lavorazione singola
   if ( dOkStep < EPS_SMALL  ||  dOkStep > dElev) {
     // se l'elevazione supera la capacità dell'utensile 
      if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
         string sInfo = "Warning in 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) {
        // segnalo, riduco e continuo
         string sInfo = "Warning in Pocketing : machining depth (" + ToString( dElev, 1) +
                        ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
         m_pMchMgr->SetWarning( 2458, sInfo) ;
         dDepth -= dElev - dMaxDepth ;
         dElev = dMaxDepth ;
      }
   }

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

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

  // verifiche per svuotature dal basso
   m_bAggrBottom = false ; 
   if ( ! VerifyPathFromBottom( pCompo, 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 = 0 ;
   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
      if ( ! GeneratePocketingPv( nPxId, pCompo))
         return false ;
   }

  // 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 i punti di inizio e fine al gruppo del percorso
      m_pGeomDB->SetInfo( nPxId, KEY_START, ptStart) ;
      m_pGeomDB->SetInfo( nPxId, KEY_END, ptStart) ;
     // assegno l'elevazione massima
      m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;

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

     // Eseguo la lavorazione a seconda del tipo
      switch ( m_Params.m_nSubType) {
      case POCKET_SUB_ZIGZAG :
      case POCKET_SUB_CONFORMAL_ZIGZAG :
         if ( ! AddZigZag( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs, nPathId))
            return false ;
         break ;
      case POCKET_SUB_ONEWAY :
      case POCKET_SUB_CONFORMAL_ONEWAY :
         if ( ! AddOneWay( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs))
            return false ;
         break ;
      case POCKET_SUB_SPIRALIN :
         if ( ! AddSpiralIn( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs, bMidOpen, ptMidOpen, vtMidOut, nPathId))
            return false ;
         break ;
      case POCKET_SUB_SPIRALOUT :
         if ( ! AddSpiralOut( pCompo, vtTool, vtExtr, dDepth, dElev, dOkStep, bSplitArcs, nPathId))
            return false ;
         break ;
      }
   }

  // incremento numero di svuotature
   ++ m_nPockets ;

   return true ;
}

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

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

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

   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::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 Pocketing : 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 Pocketing : 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
Pocketing::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 ;
}

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

//----------------------------------------------------------------------------
bool
Pocketing::AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
                      double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

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

  // determino il riferimento di base della svuotatura
   Frame3d frPocket ;
   Point3d ptCen ; pCompo->GetCentroid( ptCen) ;
   frPocket.Set( ptCen, vtExtr) ;
   frPocket.Rotate( ptCen, vtExtr, m_Params.m_dSideAngle) ;

   ICRVCOMPOPOVECTOR vpCrvs ;
   int nOffsCrvNbr = 0 ;

  // verifico se si tratta di caso ottimizzato
   bool bOptimizedZigZag = false ;
   bool bOutRawLeadIn = false ;
   double dOptZigZagOffs ;
   if ( ! OptimizedZigZag( nPathId, vtTool, dDepth, dSafeZ, frPocket, bOptimizedZigZag, vpCrvs, dOptZigZagOffs))
      return false ;
   if ( bOptimizedZigZag  &&  ! vpCrvs.empty()) {
      nOffsCrvNbr = 1 ;
     // verifico se attacco fuori dal grezzo
      Point3d ptStart ;
      vpCrvs[0]->GetStartPoint( ptStart) ;
      Vector3d vtDir ;
      vpCrvs[0]->GetStartDir( vtDir) ;
      ptStart += -vtDir * ( m_TParams.m_dDiam / 2 - dOptZigZagOffs + dSafeZ) ;
      ptStart.ToGlob( frPocket) ;
      ptStart += -vtTool * dDepth ;
      double dTestElev ;
      if ( ! GetElevation( m_nPhase, ptStart, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElev)  ||  dTestElev < EPS_SMALL)
         bOutRawLeadIn = true ;
     // sistemo attacco (per essere completamente fuori dal grezzo)
      if ( bOutRawLeadIn  ||  m_bOpenOutRaw)
         vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 2 - dOptZigZagOffs + dSafeZ) ;
   }

   // se non ottimizzato e utensile che non lavora di testa poichè ingresso non fuori dal pezzo, errore
   if ( ( ! bOptimizedZigZag  ||  ! ( bOutRawLeadIn  ||  m_bOpenOutRaw))  &&  m_TParams.m_nType == TT_MILL_NOTIP) {
      if ( ! LeadInRawIsOk()) { 
         m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
         return false ;
      }
   }
 
  // se caso non ottimizzato calcolo curva offsettata del raggio utensile + sovramateriale + (se non lucidatura) extra
   double dTRad = m_TParams.m_dDiam / 2 ;
   double dOffs = dTRad + GetOffsR() ;
   double dExtra = (( m_TParams.m_nType != TT_MILL_POLISHING) ? min( 0.1 * m_TParams.m_dDiam, 2.0) : 0) ;
   OffsetCurve OffsCrv ;
   if ( ! bOptimizedZigZag) {      
      if ( ! OffsCrv.Make( pCompo, - ( dOffs + dExtra), ICurve::OFF_FILLET)) {
         m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
         return false ;
      }
      nOffsCrvNbr = OffsCrv.GetCurveCount() ;
   }

  // ciclo sulle curve risultanti
   bool bStart = true ; 
   while ( nOffsCrvNbr > 0) {

      if ( bOptimizedZigZag)
         nOffsCrvNbr = 0 ;    // setto a zero per non rientrare nel while 
      else {
        // recupero la prima curva di offset
         PtrOwner<ICurveComposite> pOffs ;
         if ( ! pOffs.Set( ConvertCurveToComposite( OffsCrv.GetLongerCurve()))) {
            m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
            return false ;
         }
         nOffsCrvNbr = OffsCrv.GetCurveCount() ;

        // porto la curva nel riferimento della svuotatura 
          pOffs->ToLoc( frPocket) ;
       
        // calcolo i percorsi di svuotatura
         vpCrvs.clear() ;
         if ( ! CalcZigZag( pOffs, vpCrvs))
           return false ;
      }

     // se lucidatura
      if ( m_TParams.m_nType == TT_MILL_POLISHING) {
        // ciclo sui percorsi
         for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
           // se attacco a scivolo
            if ( GetLeadInType() == POCKET_LI_GLIDE) {
               double dU ;
               vpCrvs[k]->GetParamAtLength( m_Params.m_dLiTang, dU) ;
               vpCrvs[k]->AddJoint( dU) ;
               Point3d ptStart ;
               vpCrvs[k]->GetStartPoint( ptStart) ;
               vpCrvs[k]->ModifyStart( ptStart + vtTool * m_Params.m_dLiElev) ;
            }
           // se uscita a scivolo
            if ( GetLeadOutType() == POCKET_LO_GLIDE) {
               double dLen, dU ;
               vpCrvs[k]->GetLength( dLen) ;
               vpCrvs[k]->GetParamAtLength( dLen - m_Params.m_dLoTang, dU) ;
               vpCrvs[k]->AddJoint( dU) ;
               Point3d ptEnd ;
               vpCrvs[k]->GetEndPoint( ptEnd) ;
               vpCrvs[k]->ModifyEnd( ptEnd + vtTool * m_Params.m_dLiElev) ;
            }
         }
      }

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

     // inserisco i movimenti di svuotatura
      for ( int j = 1 ; j <= nStep ; ++ j) {
        // ciclo sui percorsi
         int nPath = int( vpCrvs.size()) ;
         for ( int k = 0 ; k < nPath ; ++ k) {
           // ciclo sulle curve elementari
            int nMaxInd = vpCrvs[k]->GetCurveCount() - 1 ;
            for ( int i = 0 ; i <= nMaxInd ; ++ i) {
              // curva corrente
               const ICurve* pCrvC = vpCrvs[k]->GetCurve( i) ;
              // copio la curva
               PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
               if ( IsNull( pCurve))
                  return false ;
               pCurve->ToGlob( frPocket) ;
              // aggiungo affondamento
               pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
              // se prima entità
               if ( i == 0 ) {
                 // dati inizio entità
                  Point3d ptStart ;
                  pCurve->GetStartPoint( ptStart) ;
                  Vector3d vtStart ;
                  pCurve->GetStartDir( vtStart) ;
                 // determino inizio attacco
                  Point3d ptP1 ;
                  if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, nullptr, ptP1))
                     return false ;
                 // determino elevazione su inizio attacco
                  double dStElev ;
                  GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev) ;
                  dStElev = max( dStElev, j * dStep) ;
                  bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                     GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  bool bUhAboveRaw = ! m_bAboveHead  &&
                                     GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  if ( bAhUnderRaw  ||  bUhAboveRaw)
                     dStElev = max( dStElev, j * dStep) ;
                  dStElev -= ( ptP1 - ptStart) * vtExtr ;
                 // se ottimizzata e attacco nel grezzo
                  if ( bOptimizedZigZag  &&  ! ( bOutRawLeadIn  ||  m_bOpenOutRaw)) {
                    // se richiesto attacco a zigzag o a spirale, l'elevazione va nell'attacco
                     if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||  GetLeadInType() == POCKET_LI_HELIX) {
                        ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
                        dStElev = -LIO_ELEV_TOL ;
                     }
                  }
                 // se inizio, approccio globale al punto iniziale
                  if ( bStart) {
                     if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, bOutRawLeadIn || m_bOpenOutRaw)) {
                        m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
                        return false ;
                     }
                     bStart = false ;
                  }
                 // altrimenti, approccio di collegamento
                  else {
                     if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, bOutRawLeadIn || m_bOpenOutRaw)) {
                        m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                        return false ;
                     }
                  }
                 // aggiungo attacco
                  SetFeed( GetStartFeed()) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, 
                                    bSplitArcs, bOutRawLeadIn || m_bOpenOutRaw)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
               }
              // elaborazioni sulla curva corrente
               if ( pCurve->GetType() == CRV_LINE) {
                  ICurveLine* pLine = GetCurveLine( pCurve) ;
                  Point3d ptP3 = pLine->GetEnd() ;
                  SetFeed( GetFeed()) ;
                  if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                     return false ;
               }
               else if ( pCurve->GetType() == CRV_ARC) {
                  ICurveArc* pArc = GetCurveArc( pCurve) ;
                  Point3d ptCen = pArc->GetCenter() ;
                  double dAngCen = pArc->GetAngCenter() ;
                  Vector3d vtN = pArc->GetNormVersor() ;
                  Point3d ptP3 ;
                  pArc->GetEndPoint( ptP3) ;
                  SetFeed( GetFeed()) ;
                  if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                     return false ;
               }
              // se ultima entità
               if ( i == nMaxInd) {
                 // dati fine entità
                  Point3d ptEnd ;
                  pCurve->GetEndPoint( ptEnd) ;
                  Vector3d vtEnd ;
                  pCurve->GetEndDir( vtEnd) ;
                 // aggiungo uscita
                  double dEndElev = dElev ;
                  Point3d ptP1 ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, true, ptP1, dEndElev)) {
                     m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                     return false ;
                  }
                 // se lucidatura o caso ottimizzato e ultimo percorso di ultimo step, aggiungo retrazione
                  if ( ( m_TParams.m_nType == TT_MILL_POLISHING  ||  bOptimizedZigZag)  &&  k == nPath - 1  &&  j == nStep) {
                     if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Retract not computable") ;
                        return false ;
                     }
                  }
                 // altrimenti, aggiungo retrazione di collegamento
                  else {
                     if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                        return false ;
                     }
                  }
               }
            }
         }
      }
   }

  // se lucidatura o caso ottimizzato, non aggiungo contorno
   if ( m_TParams.m_nType == TT_MILL_POLISHING  ||  bOptimizedZigZag)
      return true ;

  // calcolo seconda curva offsettata del raggio utensile + sovramateriale
   OffsetCurve OffsCrv2 ;
   if ( ! OffsCrv2.Make( pCompo, - dOffs, ICurve::OFF_FILLET)) {
      m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
      return false ;
   }

  // ciclo sulle curve risultanti
   while ( OffsCrv2.GetCurveCount() > 0) {

     // recupero la prima curva di offset
      PtrOwner<ICurveComposite> pOffs2 ;
      if ( ! pOffs2.Set( ConvertCurveToComposite( OffsCrv2.GetLongerCurve()))) {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }

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

     // se richiesto, la inverto
      if ( m_Params.m_bInvert)
         pOffs2->Invert() ;

     // sposto l'inizio a metà del tratto più lungo
      AdjustContourStart( pOffs2) ;

     // aggiungo la lavorazione di questa curva
      Point3d ptP1 ;
      for ( int j = 1 ; j <= nStep ; ++ j) {
        // ciclo sulle curve elementari
         int nMaxInd = pOffs2->GetCurveCount() - 1 ;
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pOffs2->GetCurve( i) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
           // aggiungo affondamento
            pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
           // se prima entità
            if ( i == 0 ) {
              // dati inizio entità
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               Vector3d vtStart ;
               pCurve->GetStartDir( vtStart) ;
              // se primo step, approccio e affondo
               if ( j == 1) {
                 // determino inizio attacco
                  if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, nullptr, ptP1))
                     return false ;
                 // determino elevazione su inizio attacco
                  double dStElev ;
                  if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool,
                                       GetRadiusForStartEndElevation(), vtTool, dStElev))
                     dStElev = dStep ;
                  bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                     GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  bool bUhAboveRaw = ! m_bAboveHead  &&
                                     GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab)
                     dStElev = max( dStElev, dStep) ;
                  dStElev -= ( ptP1 - ptStart) * vtExtr ;
                 // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
                  if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
                       GetLeadInType() == POCKET_LI_HELIX  ||
                       GetLeadInType() == POCKET_LI_GLIDE) {
                     ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
                     dStElev = -LIO_ELEV_TOL ;
                  }
                 // approccio al punto iniziale
                  if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
                 // aggiungo attacco
                  SetFeed( GetStartFeed()) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
               }
              // altrimenti solo collegamento
               else {
                  SetFeed( GetStartFeed()) ;
                  GetCurrPos( ptP1) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
           // elaborazioni sulla curva corrente
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               Point3d ptP3 = pLine->GetEnd() ;
               SetFeed( GetFeed()) ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
            else if ( pCurve->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCurve) ;
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ;
               pArc->GetEndPoint( ptP3) ;
               SetFeed( GetFeed()) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
           // se ultima entità
            if ( i == nMaxInd) {
              // se ultimo step, uscita e retrazione di collegamento
               if ( j == nStep) {
                 // dati fine entità
                  Point3d ptEnd ;
                  pCurve->GetEndPoint( ptEnd) ;
                  Vector3d vtEnd ;
                  pCurve->GetEndDir( vtEnd) ;
                 // aggiungo uscita
                  double dEndElev = dElev ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, false, ptP1, dEndElev)) {
                     m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                     return false ;
                  }
                 // se ci sono ancora curve, aggiungo retrazione di collegamento
                  if ( OffsCrv2.GetCurveCount() > 0) {
                     if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                        return false ;
                     }
                  }
                 // altrimenti retrazione finale
                  else {
                     if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Retract not computable") ;
                        return false ;
                     }
                  }
               }
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::CalcZigZag( const ICurveComposite* pOffs, 
                       ICRVCOMPOPOVECTOR& vpCrvs)
{
  // ingombro del contorno offsettato
   BBox3d b3Pocket ;
   pOffs->GetLocalBBox( b3Pocket) ;
   Point3d ptMin ; double dDimX, dDimY, dDimZ ;
   b3Pocket.GetMinDim( ptMin, dDimX, dDimY, dDimZ) ;

  // lunghezza del contorno offsettato
   double dLen ; pOffs->GetLength( dLen) ;

  // passi in Y
   int nYStep = static_cast<int>( ceil( ( dDimY - 30 * EPS_SMALL) / GetSideStep())) ;
   double dYStep = ( nYStep > 0 ? ( dDimY - 30 * EPS_SMALL) / nYStep : 0) ;
   int nRef = ( ( nYStep + ( m_Params.m_bInvert ? 0 : 1)) % 2) ;

  // tratto valido
   struct Section {
      bool    bActive ;
      Point3d ptS ;
      Point3d ptE ;
      double  dOs ;
      double  dOe ;
   } ;
  // raccolta di tratti
   typedef vector<vector<Section>> VECVECSECT ;

   VECVECSECT vvSec ;
   vvSec.resize( nYStep + 1) ;

  // calcolo le linee di svuotatura
   int nCount = 0 ;
   for ( int i = 0 ; i <= nYStep ; ++ i) {
     // determino senso
      bool bPlus = (( i % 2) == nRef) ;
     // definisco la linea
      PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
      const double EXP_LEN = 1.0 ;
      Point3d ptStart( ptMin.x - EXP_LEN, ptMin.y + 10 * EPS_SMALL + i * dYStep, ptMin.z + dDimZ) ;
      if ( IsNull( pLine)  ||  ! pLine->SetPVL( ptStart, X_AX, dDimX + 2 * EXP_LEN)) {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }
     // calcolo la classificazione della curva rispetto al contorno esterno offsettato
      IntersCurveCurve intCC( *pLine, *pOffs) ;
      CRVCVECTOR ccClass ;
      if ( ! intCC.GetCurveClassification( 0, EPS_SMALL, ccClass)) {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }
     // determino gli intervalli di curva da conservare
      Intervals inOk ;
      for ( auto& ccOne : ccClass) {
         if ( ccOne.nClass == CRVC_IN  ||  ccOne.nClass == CRVC_ON_P  ||  ccOne.nClass == CRVC_ON_M)
            inOk.Add( ccOne.dParS, ccOne.dParE) ;
      }
     // inserisco i tratti validi (secondo X+ i pari, secondo X- i dispari)
      double dParS, dParE ;
      bool bFound = ( bPlus ? inOk.GetFirst( dParS, dParE) : inOk.GetLast( dParE, dParS)) ;
      while ( bFound) {
        // determino i dati della sezione
         Section Sect ;
         Sect.bActive = true ;
         pLine->GetPointD1D2( dParS, ICurve::FROM_PLUS, Sect.ptS) ;
         pLine->GetPointD1D2( dParE, ICurve::FROM_MINUS, Sect.ptE) ;
         pOffs->GetParamAtPoint( Sect.ptS, Sect.dOs, 10 * EPS_SMALL) ;
         pOffs->GetParamAtPoint( Sect.ptE, Sect.dOe, 10 * EPS_SMALL) ;
        // inserisco nel contenitore
         vvSec[i].emplace_back( Sect) ;
         ++ nCount ;
        // recupero successivo intervallo
         bFound = ( bPlus ? inOk.GetNext( dParS, dParE) : inOk.GetPrev( dParE, dParS)) ;
      }
   }

  // dominio del contorno
   double dUmin, dUmax ;
   pOffs->GetDomain( dUmin, dUmax) ;
   double dUspan = dUmax - dUmin ;

  // creo i percorsi di svuotatura
   vpCrvs.reserve( nCount) ;
   int nI = -1, nJ = -1 ;
   while ( true) {
     // se sezione non valida
      if ( nI < 0  ||  nJ < 0) {
        // ricerco la prima valida
         for ( int k = 0 ; k < int( vvSec.size()) && nI < 0 ; ++ k) {
            for ( int l = 0 ; l < int( vvSec[k].size()) && nJ < 0 ; ++ l) {
               if ( vvSec[k][l].bActive) {
                  nI = k ;
                  nJ = l ;
               }
            }
         }
        // se trovata, creo nuova curva composita
         if ( nI >= 0  &&  nJ >= 0) {
           // creo la curva
            vpCrvs.emplace_back( CreateCurveComposite()) ;
           // aggiungo punto iniziale
            vpCrvs.back()->AddPoint( vvSec[nI][nJ].ptS) ;
         }
        // altrimenti, esco
         else
            break ;
      }
     // determino senso
      bool bPlus = (( nI % 2) == nRef) ;
     // aggiungo la sezione alla curva
      Section& Sec = vvSec[nI][nJ] ;
      Sec.bActive = false ;
      vpCrvs.back()->AddLine( vvSec[nI][nJ].ptE) ;
     // cerco nella stessa fila o in quella successiva sezione successiva raccordabile tramite il contorno
      double dUstart = Sec.dOe ;
      double dUref = ( bPlus ? INFINITO : - INFINITO) ;
      int nNextI = -1 ;
      int nNextJ = -1 ;
      int li =  nJ + 1 ;
      for ( int k = nI ; k <= nI + 1 && k < int( vvSec.size()) ; ++ k) {
         for ( int l = li ; l < int( vvSec[k].size()) ; ++ l) {
            if ( ! vvSec[k][l].bActive)
               continue ;
            double dU = vvSec[k][l].dOs ;
            if ( bPlus) {
               if ( dU < dUstart)
                  dU += dUspan ;
               if ( dU < dUref) {
                  dUref = dU ;
                  nNextI = k ;
                  nNextJ = l ;
               }
            }
            else {
               if ( dU > dUstart)
                  dU -= dUspan ;
               if ( dU > dUref) {
                  dUref = dU ;
                  nNextI = k ;
                  nNextJ = l ;
               }
            }
         }
         li = 0 ;
      }
     // se trovato, aggiungo il tratto di contorno e continuo
      if ( nNextI != -1) {
         PtrOwner<ICurve> pCopy ;
         if ( bPlus) {
            if ( dUref > dUmax)
               dUref -= dUspan ;
            pCopy.Set( pOffs->CopyParamRange( dUstart, dUref)) ;
            if ( ! IsNull( pCopy)) {
               double dCLen ; pCopy->GetLength( dCLen) ;
               if ( dCLen > 0.5 * dLen) {
                  pCopy.Set( pOffs->CopyParamRange( dUref, dUstart)) ;
                  if ( ! IsNull( pCopy))
                     pCopy->Invert() ;
               }
            }
         }
         else {
            if ( dUref < dUmin)
               dUref += dUspan ;
            pCopy.Set( pOffs->CopyParamRange( dUref, dUstart)) ;
            if ( ! IsNull( pCopy)) {
               pCopy->Invert() ;
               double dCLen ; pCopy->GetLength( dCLen) ;
               if ( dCLen > 0.5 * dLen)
               pCopy.Set( pOffs->CopyParamRange( dUstart, dUref)) ;
            }
         }
         BBox3d b3Copy ;
         if ( ! IsNull( pCopy))
            pCopy->GetLocalBBox( b3Copy) ;
         if ( ! b3Copy.IsEmpty()  &&  ( b3Copy.GetMax().y - b3Copy.GetMin().y) < dYStep + 10 * EPS_SMALL) {
            vpCrvs.back()->AddCurve( Release( pCopy)) ;
            nI = nNextI ;
            nJ = nNextJ ;
         }
         else {
            nI = -1 ;
            nJ = -1 ;
         }
      }
      else {
         nI = -1 ;
         nJ = -1 ;
      }
   }
   return true ;
}

//----------------------------------------------------------
bool 
Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ,
                            Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs)
{
  // recupero la curva originale che delimita la svuotatura 
   int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
   PtrOwner<ICurveComposite> pCrvPocket( CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId))) ;
   if ( IsNull( pCrvPocket))
      return false ;
   pCrvPocket->ToLoc( frPocket) ;
   SetCurveAllTempProp( nCrvId, GetForcedClosed(), pCrvPocket) ;
   pCrvPocket->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
  // sistemo senso antiorario visto dalla direzione di estrusione
   Vector3d vtPocket; pCrvPocket->GetExtrusion( vtPocket) ;
   Plane3d plPlane ; double dArea ;
   pCrvPocket->GetArea( plPlane, dArea) ;
   if ( plPlane.GetVersN() * vtPocket * dArea < 0)
      pCrvPocket->Invert() ;

  // recupero gli id dei lati chiusi
   INTVECTOR vnInfoClosed ; 
   for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
      int nProp ;
      if ( pCrvPocket->GetCurveTempProp( i, nProp) && nProp == 0)
         vnInfoClosed.push_back( i) ;
   }
   int nClosedSides = vnInfoClosed.size() ;

  // modifico pCrvPocket per poterla passare a CalcZigZag
   bool bTwoOpposite ;
   Vector3d vtDir ;
   switch ( nClosedSides) {
   case 0 :
      ZigZagOptimizedNoClosedEdges( pCrvPocket, bOptimizedZigZag, vtDir, dOffs) ;
      break ;
   case 1 :
      ZigZagOptimizedOneClosedEdge( pCrvPocket, vnInfoClosed[0], bOptimizedZigZag, vtDir, dOffs) ;
      break ;
   case 2 :
      ZigZagOptimizedTwoClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir, dOffs) ;
      break ;
   case 3 :
      ZigZagOptimizedThreeClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir, dOffs) ;
      break ;
   default :
      bOptimizedZigZag = false ;
      break ;
   }

   if ( ! bOptimizedZigZag)
      return true ;

  // oriento il frame della svuotatura allineando asse X con vtDir
   if ( vtDir.IsZero()) 
      pCrvPocket->GetStartDir( vtDir) ;
   double dAng ;
   vtDir.GetAngleXY( X_AX, dAng) ;
   if ( nClosedSides == 0)
      dAng += m_Params.m_dSideAngle ;
   pCrvPocket->ToGlob( frPocket) ;
   Point3d ptCen = frPocket.Orig() ; 
   Vector3d vtExtr = frPocket.VersZ() ; 
   frPocket.Rotate( ptCen, vtExtr, -dAng) ;
   pCrvPocket->ToLoc( frPocket) ;

  // calcolo il percorso di svuotatura
   if ( ! CalcZigZag( pCrvPocket, vpCrvs))
       return false ;
  
  // se un lato chiuso
   if ( nClosedSides == 1) {
     // inverto il percorso
      vpCrvs[0]->Invert() ;
     // verifico se attacco fuori dal grezzo
      Point3d ptStart ;
      vpCrvs[0]->GetStartPoint( ptStart) ;
      Vector3d vtDir ;
      vpCrvs[0]->GetStartDir( vtDir) ;
      Point3d ptTest = ptStart + ( -vtDir) * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ;
      ptTest.ToGlob( frPocket) ;
      ptTest += - vtTool * dDepth ;
      double dTestElev ;
     // se è nel grezzo provo a ruotare di 90 gradi
      if ( GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElev)  &&  dTestElev > EPS_SMALL) {
         Vector3d vtDirO = vtDir ;
         vtDirO.Rotate( Z_AX, ( m_Params.m_bInvert ? -90 : 90)) ;
         Point3d ptTestO = ptStart + vtDirO * ( m_TParams.m_dDiam / 2 - dOffs + dSafeZ) ;
         ptTestO.ToGlob( frPocket) ;
         ptTestO += - vtTool * dDepth ;
         double dTestElevO ;
        // se è fuori dal grezzo uso inizio ruotato
         if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2 - dOffs, vtTool, dTestElevO)  ||  dTestElevO < EPS_SMALL) {
            Point3d ptNewStart = ptStart + vtDirO ;
            vpCrvs[0]->AddLine( ptNewStart, false) ;
         }
      }
   }
  // se due lati chiusi consecutivi o tre lati chiusi...
   else if ( ( nClosedSides == 2 || nClosedSides == 3) &&  ! bTwoOpposite) {
     // inverto il percorso
      vpCrvs[0]->Invert() ;
     // allungo opportunamente inizio e fine
      Point3d ptStart ;
      vpCrvs[0]->GetStartPoint( ptStart) ;
      Vector3d vtDir ;
      vpCrvs[0]->GetStartDir( vtDir) ;
      vtDir.Rotate( Z_AX, ( m_Params.m_bInvert ? -90 : 90)) ;
      ptStart += vtDir ;
      Point3d ptEnd ;
      vpCrvs[0]->GetEndPoint( ptEnd) ;
      ptEnd += OrthoCompo( ptStart - ptEnd, X_AX) ;
      vpCrvs[0]->AddLine( ptEnd, true) ;
      vpCrvs[0]->AddLine( ptStart, false) ;
   }

  // estendo la fine del percorso
   if ( ! ( nClosedSides == 3  &&  bTwoOpposite))
      vpCrvs[0]->ExtendEndByLen( max( m_TParams.m_dDiam / 4 - dOffs, 0.)) ;

   return true ;
}

//------------------------------------------------------------------
bool 
Pocketing::ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs)
{
  // individuo il segmento di retta più lungo
   int nMax = -1 ;
   double dMaxLen = 0 ;
   for ( int i = 0 ; i < int( pCrvPocket->GetCurveCount()) ; ++ i) {
      const ICurve* pCrv = pCrvPocket->GetCurve( i) ;
      if ( pCrv->GetType() == CRV_LINE) {
         double dLen = 0 ; pCrv->GetLength( dLen) ;
         if ( dLen > dMaxLen) {
            dMaxLen = dLen ;
            nMax = i ;
         }
      }
   }
   if ( nMax == -1)
      return true ;
   pCrvPocket->GetCurve( nMax)->GetStartDir( vtDir) ;

  // aggiorno pCrvPocket con eventuale offset per regioni residue
   if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 0, {}, dOffs))
      return true ;

   bOptimizedZigZag = true ;
   return true ;
}

//------------------------------------------------------------------
bool 
Pocketing::ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs)
{
  // verifico che il lato chiuso sia una linea
   PtrOwner<ICurveLine> pCrv( CloneCurveLine( pCrvPocket->GetCurve( nClosedId))) ;
   if ( IsNull( pCrv)) 
      return true ;

  // aggiorno pCrvPocket con eventuale offset per regioni residue
   pCrv->GetStartDir( vtDir) ;
   if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, {nClosedId}, dOffs))
      return true ;

  // setto il vettore estrusione per eseguire correttamente offset
   Vector3d vtExtr ;
   pCrvPocket->GetExtrusion( vtExtr) ;
   pCrv->SetExtrusion( vtExtr) ;

   pCrv->SimpleOffset( -m_TParams.m_dDiam / 2 - GetOffsR() + 10 * EPS_SMALL) ;
   pCrv->ExtendStartByLen( 300) ;
   pCrv->ExtendEndByLen( 300) ;

  // sarà la prima curva del percorso
   if ( ! CutCurveWithLine( pCrvPocket, pCrv))
      return false ;

   bOptimizedZigZag = true ;
   return true ;
}

//------------------------------------------------------------------
bool 
Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, 
                                          bool& bOpposite, Vector3d& vtDir, double& dOffs)
{
  // verifico che i lati chiusi siano linee
   PtrOwner<ICurveLine> pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ;
   PtrOwner<ICurveLine> pCrv2( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[1]))) ;
   if ( IsNull( pCrv1)  ||  IsNull( pCrv2)) 
      return true ;
  // verifico abbiano direzioni opposte
   Vector3d vtDir1, vtDir2 ;
   pCrv1->GetStartDir( vtDir1) ; 
   pCrv2->GetStartDir( vtDir2) ;
   if ( AreOppositeVectorApprox( vtDir1, vtDir2))
      bOpposite = true ;
   else {
     // verifico siano consecutive
      Point3d ptStart1 ;
      pCrv1->GetStartPoint( ptStart1) ;
      Point3d ptEnd1 ;
      pCrv1->GetEndPoint( ptEnd1) ;
      Point3d ptStart2 ;
      pCrv2->GetStartPoint( ptStart2) ;
      Point3d ptEnd2 ;
      pCrv2->GetEndPoint( ptEnd2) ;
      if ( AreSamePointApprox( ptEnd1, ptStart2)  ||  AreSamePointApprox( ptEnd2, ptStart1))
         bOpposite = false ;
      else
         return true ;
   }

  // setto il vettore estrusione per eseguire correttamente offset
   Vector3d vtExtr ;
   pCrvPocket->GetExtrusion( vtExtr) ;
   pCrv1->SetExtrusion( vtExtr) ;
   pCrv2->SetExtrusion( vtExtr) ;

  // determino la curva chiusa più lunga
   double dLen1 ; pCrv1->GetLength( dLen1) ;
   double dLen2 ; pCrv2->GetLength( dLen2) ;

  // se non opposti, verifico che almeno una delle due sia corta
   if ( ! bOpposite  &&  dLen1 > 1.5 * m_TParams.m_dDiam  &&  dLen2 > 1.5 * m_TParams.m_dDiam)
      return true ;

  // trovo la direzione principale della svuotatura 
   if ( dLen1 > dLen2) 
      pCrv1->GetStartDir( vtDir) ;
   else
      pCrv2->GetStartDir( vtDir) ;

  // aggiorno pCrvPocket con eventuale offset per regioni residue
   if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, bOpposite ? 2 : 1, vnClosedIds, dOffs))
      return true ;

   double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
   pCrv1->SimpleOffset( -dMyOffs) ;
   pCrv1->ExtendStartByLen( 300) ;
   pCrv1->ExtendEndByLen( 300) ;
   if ( ! CutCurveWithLine( pCrvPocket, pCrv1))
      return false ;

  // sarà la prima curva del percorso
   pCrv2->SimpleOffset( -dMyOffs) ;
   pCrv2->ExtendStartByLen( 300) ;
   pCrv2->ExtendEndByLen( 300) ;
   if ( ! CutCurveWithLine( pCrvPocket, pCrv2))
      return false ;

   bOptimizedZigZag = true ;
   return true ;
}

//------------------------------------------------------------------
bool 
Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
                                            bool& bOpposite, Vector3d& vtDir, double& dOffs)
{
  // verifico che i lati chiusi siano linee
   PtrOwner<ICurveLine> pCrv1( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[0]))) ;
   PtrOwner<ICurveLine> pCrv2( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[1]))) ;
   PtrOwner<ICurveLine> pCrv3( CloneCurveLine( pCrvPocket->GetCurve( vnClosedIds[2]))) ;
   if ( IsNull( pCrv1)  ||  IsNull( pCrv2)  ||  IsNull( pCrv3)) 
      return true ;
  // verifico siano consecutivi
   Point3d ptStart1 ;
   pCrv1->GetStartPoint( ptStart1) ;
   Point3d ptEnd1 ;
   pCrv1->GetEndPoint( ptEnd1) ;
   Point3d ptStart2 ;
   pCrv2->GetStartPoint( ptStart2) ;
   Point3d ptEnd2 ;
   pCrv2->GetEndPoint( ptEnd2) ;
   Point3d ptStart3 ;
   pCrv3->GetStartPoint( ptStart3) ;
   Point3d ptEnd3 ;
   pCrv3->GetEndPoint( ptEnd3) ;
   if ( AreSamePointApprox( ptEnd1, ptStart2)  &&  AreSamePointApprox( ptEnd2, ptStart3))
      ;
   else if ( AreSamePointApprox( ptEnd2, ptStart3)  &&  AreSamePointApprox( ptEnd3, ptStart1)) {
      swap( pCrv1, pCrv2) ;
      swap( pCrv2, pCrv3) ;
   }
   else if ( AreSamePointApprox( ptEnd3, ptStart1)  &&  AreSamePointApprox( ptEnd1, ptStart2)) {
      swap( pCrv1, pCrv3) ;
      swap( pCrv3, pCrv2) ;
   }
   else
      return true ;
  // calcolo la direzione della svuotatura e verifico che lati non siano troppo lunghi
   double dLen1 ; pCrv1->GetLength( dLen1) ;
   double dLen2 ; pCrv2->GetLength( dLen2) ;
   double dLen3 ; pCrv3->GetLength( dLen3) ;
   if ( dLen2 > dLen1  &&  dLen2 > dLen3) {
      if ( dLen1 > 1.5 * m_TParams.m_dDiam  ||  dLen3 > 1.5 * m_TParams.m_dDiam)
         return true ;
      pCrv2->GetStartDir( vtDir) ;
      bOpposite = false ;
   }
   else {
      if ( dLen2 > 1.5 * m_TParams.m_dDiam)
         return true ;
      pCrv3->GetStartDir( vtDir) ;
      bOpposite = true ;
   }   

  // aggiorno pCrvPocket con eventuale offset per regioni residue
   if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds, dOffs))
      return true ;

  // setto il vettore estrusione per eseguire correttamente offset
   Vector3d vtExtr ;
   pCrvPocket->GetExtrusion( vtExtr) ;
   pCrv1->SetExtrusion( vtExtr) ;
   pCrv2->SetExtrusion( vtExtr) ;
   pCrv3->SetExtrusion( vtExtr) ;

   double dMyOffs = m_TParams.m_dDiam / 2 + GetOffsR() - 10 * EPS_SMALL ;
   pCrv1->SimpleOffset( -dMyOffs) ;
   pCrv1->ExtendStartByLen( 300) ;
   pCrv1->ExtendEndByLen( 300) ;
   if ( ! CutCurveWithLine( pCrvPocket, pCrv1))
      return false ;

   pCrv3->SimpleOffset( -dMyOffs) ;
   pCrv3->ExtendStartByLen( 300) ;
   pCrv3->ExtendEndByLen( 300) ;
   if ( ! CutCurveWithLine( pCrvPocket, pCrv3))
      return false ;

  // sarà la prima curva del percorso
   pCrv2->SimpleOffset( -dMyOffs) ;
   pCrv2->ExtendStartByLen( 300) ;
   pCrv2->ExtendEndByLen( 300) ;
   if ( ! CutCurveWithLine( pCrvPocket, pCrv2))
      return false ;

   bOptimizedZigZag = true ;
   return true ;
}

//------------------------------------------------------------------
 bool 
 Pocketing::ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, 
                                          const INTVECTOR& vnClosedIds, double& dOffs)
 { 
   // calcolo il side step che verrà utilizzato in CalcZigZag
    Frame3d frLoc ;
    if ( ! frLoc.Set( ORIG, Z_AX, vtMainDir))
       return true ;
    BBox3d b3Loc ;
    pCrvPocket->ToLoc( frLoc) ;
    pCrvPocket->GetLocalBBox( b3Loc) ;
    pCrvPocket->ToGlob( frLoc) ;
    Point3d pt ;
    double dDimX, dDimY, dDimZ ;
    b3Loc.GetMinDim( pt, dDimX, dDimY, dDimZ) ;
   // riduco la DimY della svuotatura in base al numero di lati chiusi che saranno offsettati lungo quella direzione
    dDimY -= nOffsettedEdgesOnY * ( 0.5 * m_TParams.m_dDiam + GetOffsR()) ;
    int nYStep = static_cast<int>( ceil( ( dDimY - 30 * EPS_SMALL) / GetSideStep())) ;
    double dYSideStep = ( nYStep > 0 ? ( dDimY - 30 * EPS_SMALL) / nYStep : 0) ;
 
   // individuo i lati vicini a quelli closed
    for ( int i = 0 ; i < ( int)vnClosedIds.size() ; i ++) {
       int nNext = vnClosedIds[i] == pCrvPocket->GetCurveCount() - 1 ? 0 : vnClosedIds[i] + 1 ;      
       int nPrev = vnClosedIds[i] == 0 ? pCrvPocket->GetCurveCount() - 1 : vnClosedIds[i] - 1 ;
       pCrvPocket->SetCurveTempProp( nNext, 1, 1) ;
       pCrvPocket->SetCurveTempProp( nPrev, 1, 1) ;    
    }

   // verifico se resteranno aree residue e calcolo eventuale offset per pCrvPocket
    dOffs = 0 ;
    for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
 
       double dOffsTmp = 0 ;
       double dVal = 0 ;
 
       if ( pCrvPocket->GetCurve(i)->GetType() == CRV_LINE) {
          Vector3d vtDir ;
          if ( ! pCrvPocket->GetCurve( i)->GetStartDir( vtDir))
             return false ;

          int nProp ;
          pCrvPocket->GetCurveTempProp( i, nProp, 1) ;
          double dLen ;
          pCrvPocket->GetCurve( i)->GetLength( dLen) ;

          if ( nProp == 1 && dLen > 1000 * EPS_SMALL) {
            // gestione speciale se vicino al lato closed 
             double dCosAlpha = vtMainDir * vtDir ;
             if ( abs( dCosAlpha) > EPS_SMALL && abs( dCosAlpha) < 1 - EPS_SMALL)
                dOffsTmp = abs( 0.5 * m_TParams.m_dDiam * dCosAlpha) ;          
          }
          else {
             double dSinAlpha = ( vtMainDir ^ vtDir).Len() ;
             if ( abs( dSinAlpha) > EPS_SMALL)
                dVal = ( dYSideStep - 0.5 * m_TParams.m_dDiam) / dSinAlpha - 0.5 * m_TParams.m_dDiam ;
             if ( dVal > EPS_SMALL) {
                double dCosAlpha = vtMainDir * vtDir ;
                dOffsTmp = abs( ( dYSideStep - 0.5 * m_TParams.m_dDiam) * dCosAlpha) ;
             }
          }
       }
       if ( dOffsTmp > dOffs)
          dOffs = dOffsTmp ;
    }

   // aggiusto offset
    double dMinOffs = max( 0., 0.5 * m_TParams.m_dDiam - m_Params.m_dSideStep) ; 
    dOffs = max( dOffs, dMinOffs) ;

    if ( dOffs > EPS_SMALL) {
      // calcolo offset
       OffsetCurve OffsCrv ;
       if ( ! OffsCrv.Make( pCrvPocket, dOffs, ICurve::OFF_EXTEND)) {
          m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
          return false ;
       }
       if ( OffsCrv.GetCurveCount() > 1)
          return false ;
 
      // aggiorno pCrvPocket 
       pCrvPocket->Clear() ;
       pCrvPocket->AddCurve( OffsCrv.GetCurve()) ;
    }
 
    return true ;
 }

//------------------------------------------------------------------
bool 
Pocketing::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
Pocketing::AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
                      double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // se utensile che non lavora di testa poichè ingresso non fuori dal pezzo, errore
   if ( m_TParams.m_nType == TT_MILL_NOTIP) {
      if ( ! LeadInRawIsOk()) { 
         m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
         return false ;
      }
   }

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

  // calcolo curva offsettata del raggio utensile + sovramateriale
   double dTRad = 0.5 * m_TParams.m_dDiam ;
   double dOffs = dTRad + GetOffsR() ;
   OffsetCurve OffsCrv ;
   if ( ! OffsCrv.Make( pCompo, - dOffs, ICurve::OFF_FILLET)) {
      m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
      return false ;
   }

  // ciclo sulle curve risultanti
   while ( OffsCrv.GetCurveCount() > 0) {

     // recupero la prima curva di offset
      PtrOwner<ICurveComposite> pOffs ;
      if ( ! pOffs.Set( ConvertCurveToComposite( OffsCrv.GetLongerCurve()))) {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }

     // se richiesto, la inverto
      if ( m_Params.m_bInvert)
         pOffs->Invert() ;

     // sposto l'inizio a metà del tratto più lungo
      AdjustContourStart( pOffs) ;

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

     // coefficiente di riduzione feed di lavorazione di questa curva
      double dFeedRid = min( GetSideStep() / m_TParams.m_dDiam, 1.0) ;

     // aggiungo la lavorazione di questa curva
      Point3d ptP1 ;
      for ( int j = 1 ; j <= nStep ; ++ j) {
        // ciclo sulle curve elementari
         int nMaxInd = pOffs->GetCurveCount() - 1 ;
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pOffs->GetCurve( i) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
           // aggiungo affondamento
            pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
           // se prima entità
            if ( i == 0 ) {
              // dati inizio entità
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               Vector3d vtStart ;
               pCurve->GetStartDir( vtStart) ;
              // se primo step, approccio e affondo
               if ( j == 1) {
                 // determino inizio attacco
                  if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, nullptr, ptP1))
                     return false ;
                 // determino elevazione su inizio attacco
                  double dStElev ;
                  if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                     dStElev = dStep ;
                  bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                     GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  bool bUhAboveRaw = ! m_bAboveHead  &&
                                     GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab)
                     dStElev = max( dStElev, dStep) ;
                  dStElev -= ( ptP1 - ptStart) * vtExtr ;
                 // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
                  if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
                       GetLeadInType() == POCKET_LI_HELIX  ||
                       GetLeadInType() == POCKET_LI_GLIDE) {
                     ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
                     dStElev = -LIO_ELEV_TOL ;
                  }
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, false)) {
                     m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
                     return false ;
                  }
                 // aggiungo attacco
                  SetFeed( GetStartFeed()) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
               }
              // altrimenti solo collegamento
               else {
                  SetFeed( GetStartFeed()) ;
                  GetCurrPos( ptP1) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
           // elaborazioni sulla curva corrente
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               Point3d ptP3 = pLine->GetEnd() ;
               SetFeed( dFeedRid * GetFeed()) ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
            else if ( pCurve->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCurve) ;
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ;
               pArc->GetEndPoint( ptP3) ;
               SetFeed( dFeedRid * GetFeed()) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
           // se ultima entità
            if ( i == nMaxInd) {
              // se ultimo step, uscita e retrazione di collegamento
               if ( j == nStep) {
                 // dati fine entità
                  Point3d ptEnd ;
                  pCurve->GetEndPoint( ptEnd) ;
                  Vector3d vtEnd ;
                  pCurve->GetEndDir( vtEnd) ;
                 // aggiungo uscita
                  Point3d ptP1 ;
                  double dEndElev = dElev ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, nullptr, bSplitArcs, false, ptP1, dEndElev)) {
                     m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                     return false ;
                  }
                  // aggiungo retrazione
                  if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
         }
      }
   }

  // calcolo seconda curva di offset
   OffsetCurve OffsCrv2 ;
   double dExtra = min( 0.1 * m_TParams.m_dDiam, 1.0) ;
   if ( ! OffsCrv2.Make( pCompo, - ( dOffs + dExtra), ICurve::OFF_FILLET)) {
      m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
      return false ;
   }

  // ciclo sulle curve risultanti
   while ( OffsCrv2.GetCurveCount() > 0) {

      PtrOwner<ICurveComposite> pOffs2 ;
      if ( ! pOffs2.Set( ConvertCurveToComposite( OffsCrv2.GetLongerCurve()))) {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }

     // determino il riferimento di base e il box della svuotatura
      Frame3d frPocket ;
      Point3d ptCen ; pCompo->GetCentroid( ptCen) ;
      frPocket.Set( ptCen, vtExtr) ;
      frPocket.Rotate( ptCen, vtExtr, m_Params.m_dSideAngle) ;
      pOffs2->ToLoc( frPocket) ;
      BBox3d b3Pocket ;
      pOffs2->GetLocalBBox( b3Pocket) ;
      Point3d ptMin ; double dDimX, dDimY, dDimZ ;
      b3Pocket.GetMinDim( ptMin, dDimX, dDimY, dDimZ) ;

     // passi in Y
      int nYStep = static_cast<int>( ceil( ( dDimY + 2 * dExtra) / GetSideStep())) ;
      double dYStep = ( nYStep > 0 ? ( dDimY + 2 * dExtra) / nYStep : 0) ;
      -- nYStep ;

     // calcolo le linee di svuotatura
      const double EXP_LEN = 1.0 ;
      for ( int j = 1 ; j <= nStep ; ++ j) {
         for ( int i = 1 ; i <= nYStep ; ++ i) {
           // definisco la linea
            PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
            Point3d ptStart( ptMin.x - EXP_LEN, ptMin.y + ( - dExtra + i * dYStep), ptMin.z + dDimZ) ;
            if ( IsNull( pLine)  ||  ! pLine->SetPVL( ptStart, X_AX, dDimX + 2 * EXP_LEN)) {
               m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
               return false ;
            }
           // calcolo la classificazione della curva rispetto al contorno esterno offsettato
            IntersCurveCurve intCC( *pLine, *pOffs2) ;
            CRVCVECTOR ccClass ;
            if ( ! intCC.GetCurveClassification( 0, EPS_SMALL, ccClass)) {
               m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
               return false ;
            }
           // determino gli intervalli di curva da conservare
            Intervals inOk ;
            for ( auto& ccOne : ccClass) {
               if ( ccOne.nClass == CRVC_IN  ||  ccOne.nClass == CRVC_ON_P  ||  ccOne.nClass == CRVC_ON_M)
                  inOk.Add( ccOne.dParS, ccOne.dParE) ;
            }
           // inserisco i tratti validi
            double dParS, dParE ;
            bool bFound = inOk.GetFirst( dParS, dParE) ;
            while ( bFound) {
              // calcolo inizio con affondamento
               Point3d ptS ; pLine->GetPointD1D2( dParS, ICurve::FROM_PLUS, ptS) ;
               ptS.ToGlob( frPocket) ;
               ptS.Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
              // determino inizio attacco
               Point3d ptP ;
               if ( ! CalcLeadInStart( ptS, frPocket.VersX(), vtExtr, nullptr, ptP))
                  return false ;
              // determino elevazione su inizio attacco
               double dStElev ;
               if ( ! GetElevation( m_nPhase, ptS - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = j * dStep ;
               bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                  GetAhPointUnderRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(),
                                                      m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
               bool bUhAboveRaw = ! m_bAboveHead  &&
                                  GetUhPointAboveRaw( ptP, vtTool, 0, GetRadiusForStartEndElevation(),
                                                      m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
               if ( bAhUnderRaw  ||  bUhAboveRaw)
                  dStElev = max( dStElev, j * dStep) ;
               dStElev -= ( ptP - ptS) * vtExtr ;
              // sempre approccio di collegamento
               if ( ! AddLinkApproach( ptP, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                  return false ;
               }
              // aggiungo attacco
               SetFeed( GetStartFeed()) ;
               if ( ! AddLeadIn( ptP, ptS, frPocket.VersX(), vtExtr, pCompo, nullptr, ! m_Params.m_bInvert, bSplitArcs, true)) {
                  m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                  return false ;
               }
              // calcolo fine con affondamento
               Point3d ptE ; pLine->GetPointD1D2( dParE, ICurve::FROM_MINUS, ptE) ;
               ptE.ToGlob( frPocket) ;
               ptE.Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
              // movimento al punto finale
               SetFeed( GetFeed()) ;
               if ( AddLinearMove( ptE, bSplitArcs) == GDB_ID_NULL)
                  return false ;
              // risalita
               Point3d ptQ ;
               double dEndElev = dElev ;
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptE, frPocket.VersX(), vtExtr, nullptr, bSplitArcs, true, ptQ, dEndElev)) {
                  m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                  return false ;
               }
              // recupero successivo intervallo
               bFound = inOk.GetNext( dParS, dParE) ;
              // se ultimo movimento di ultima area, aggiungo retrazione globale
               if ( j == nStep  &&  i == nYStep  &&  ! bFound  &&  OffsCrv2.GetCurveCount() == 0) {
                  if ( ! AddRetract( ptQ, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ;
                     return false ;
                  }
               }
              // altrimenti aggiungo retrazione di collegamento
               else {
                  if ( ! AddLinkRetract( ptQ, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
         }
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
                        double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bMidOpen,
                        const Point3d& ptMidOpen, const Vector3d& vtMidOut, int nPathId)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // ciclo sulle regioni
   const int MAX_REGS = 50 ;
   int nReg = 0 ;
   while ( nReg < MAX_REGS) {

     // calcolo la spirale dall'esterno all'interno e la curva che unisce inizio e fine
      PtrOwner<ICurveComposite> pMCrv( CreateCurveComposite()) ;
      PtrOwner<ICurveComposite> pRCrv( CreateCurveComposite()) ;
      if ( IsNull( pMCrv)  ||  IsNull( pRCrv)) {
         m_pMchMgr->SetLastError( 2411, "Error in Pocketing : toolpath allocation failed") ;
         return false ;
      }

     // se lucidatura con epicicli
      if ( m_TParams.m_nType == TT_MILL_POLISHING && m_Params.m_dEpicyclesRad > EPS_SMALL ) {
        // verifico che i parametri lucidatura siano sensati 
         if ( m_Params.m_dEpicyclesDist < 100 * EPS_SMALL) {
            m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
            return false ;
         }
        // modifico il diametro dell'utensile per tenere conto anche del diametro degli epicicli
         m_TParams.m_dDiam += 2 * m_Params.m_dEpicyclesRad ;
      }

      bool bOptimizedTrap = false ;
      if ( ! CalcSpiral( pCompo, nReg, bSplitArcs, pMCrv, pRCrv, nPathId, bOptimizedTrap))
         return false ;
     // se terminate le regioni, esco
      if ( pMCrv->GetCurveCount() == 0)
         break ;
      ++ nReg ;

      if ( m_TParams.m_nType == TT_MILL_POLISHING  &&  m_Params.m_dEpicyclesRad > EPS_SMALL) {
        // riporto il diametro dell'utensile al valore originale
         m_TParams.m_dDiam -= 2 * m_Params.m_dEpicyclesRad ;
        // aggiorno i percorsi di svuotatura con epicicli 
         if ( ! ComputePolishingPath( pMCrv, pRCrv, bSplitArcs)) {
            m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
            return false ;
         }
      }

     // se prima regione e gestione lato aperto ( caso non ottimizzato)
      bool bOutStart = ( nReg == 1  &&  bMidOpen) ;
      if ( bOutStart  &&  ! bOptimizedTrap) {
        // calcolo il punto fuori
         Point3d ptOut = ptMidOpen + vtMidOut * ( 0.5 * m_TParams.m_dDiam + max( dSafeZ, m_dOpenMinSafe)) ;
        // verifico che il punto sia veramente fuori dal grezzo
         double dStElev ;
         bOutStart = ( ! GetElevation( m_nPhase, ptOut, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dStElev)  ||  dStElev < EPS_SMALL) ;
         if ( bOutStart  ||  m_bOpenOutRaw) {
           // aggiungo al ritorno l'uscita
            if ( pRCrv->GetCurveCount() == 0) {
               Point3d ptStart ; pMCrv->GetStartPoint( ptStart) ;
               pRCrv->AddPoint( ptStart) ;
            }
            pRCrv->AddLine( ptOut, true) ;
           // premetto alla spirale la partenza da fuori
            pMCrv->AddLine( ptOut, false) ;
         }
      }

     // calcolo gli eventuali punti fuori dal grezzo nel caso ottimizzato
      int nOutsideRaw = 0 ;
      if ( bOptimizedTrap) {
         AdjustTrapezoidSpiralForLeadInLeadOut( pMCrv, pRCrv, vtTool, dDepth, nOutsideRaw) ;
         bOutStart = ( nOutsideRaw > 0) ;
      }

     // verifico se ingresso da considerare fuori grezzo anche se dentro
      bool bForcedOutStart = ( bMidOpen  &&  m_bOpenOutRaw) ;

     // se utensile che non lavora di testa e ingresso non fuori dal pezzo, errore
      if ( m_TParams.m_nType == TT_MILL_NOTIP  &&  ! bOutStart  &&  ! bForcedOutStart) {
         if ( ! LeadInRawIsOk()) { 
            m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
            return false ;
         }
      }

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

     // ciclo sugli step
      Point3d ptP1 ;
      for ( int j = 1 ; j <= nStep ; ++ j) {
        // se sono nel caso ottimizzato e ho attacco e uscita entrambi dentro/fuori dal grezzo, ad ogni step inverto la direzione della curva
         if ( bOptimizedTrap && nOutsideRaw != 1 && j > 1)
            pMCrv->Invert() ;
        // ciclo sulle curve elementari
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pMCrv->GetCurve( i) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
           // aggiungo affondamento
            pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
           // se prima entità
            if ( i == 0 ) {
              // dati inizio entità
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               Vector3d vtStart ;
               pCurve->GetStartDir( vtStart) ;
              // se primo step, approccio e affondo
               if ( j == 1) {
                 // determino inizio attacco
                  if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, pRCrv, ptP1))
                     return false ;
                 // determino elevazione su inizio attacco (se non trovata, elevazione è step)
                  double dStElev ;
                  if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                     dStElev = dStep ;
                  bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                     GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  bool bUhAboveRaw = ! m_bAboveHead  &&
                                     GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab)
                     dStElev = max( dStElev, dStep) ;
                  dStElev -= ( ptP1 - ptStart) * vtExtr ;
                 // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
                  if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
                       GetLeadInType() == POCKET_LI_HELIX  ||
                       GetLeadInType() == POCKET_LI_GLIDE) {
                    // se lucidatura forzo il valore al parametro di elevazione in ingresso
                     if ( m_TParams.m_nType == TT_MILL_POLISHING) {
                        ptP1 += vtExtr * max( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
                        dStElev = 0 ;
                     }                        
                     else {
                        ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
                        dStElev = -LIO_ELEV_TOL ;
                     }
                  }
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, bOutStart || bForcedOutStart)) {
                     m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
                     return false ;
                  }
                 // aggiungo attacco
                  SetFeed( GetStartFeed()) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, pRCrv, ! m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
               }
              // altrimenti solo collegamento
               else {
                  SetFeed( GetStartFeed()) ;
                  GetCurrPos( ptP1) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, pRCrv, ! m_Params.m_bInvert, bSplitArcs, bOutStart || bForcedOutStart)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
           // elaborazioni sulla curva corrente
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               Point3d ptP3 = pLine->GetEnd() ;
               SetFeed( GetFeed()) ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
            else if ( pCurve->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCurve) ;
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ;
               pArc->GetEndPoint( ptP3) ;
               SetFeed( GetFeed()) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
           // se ultima entità
            if ( i == nMaxInd) {
              // se step intermedio, ritorno all'inizio direttamente
               if ( j < nStep) {
                 // se necessario ritorno all'inizio
                  if ( nMaxRInd >= 0) {
                    // copio la curva di ritorno
                     PtrOwner<ICurveComposite> pRet( pRCrv->Clone()) ;
                     if ( IsNull( pRet))
                        return false ;
                    // aggiungo affondamento
                     pRet->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
                    // se attacco a scivolo, accorcio della lunghezza dell'attacco
                     if ( GetLeadInType() == POCKET_LI_GLIDE) {
                        double dLen ; pRet->GetLength( dLen) ;
                        if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL)
                           pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang) ;
                        else
                           pRet->Clear() ;
                     }
                    // emetto
                     SetFeed( GetFeed()) ;
                     if ( pRet->GetCurveCount() > 0  &&  AddCurveMove( pRet) == GDB_ID_NULL)
                        return false ;
                  }
               }
              // atrimenti ultimo step, uscita e retrazione
               else {
                 // dati fine entità
                  Point3d ptEnd ;
                  pCurve->GetEndPoint( ptEnd) ;
                  Vector3d vtEnd ;
                  pCurve->GetEndDir( vtEnd) ;
                 // aggiungo uscita
                  Point3d ptP1 ;
                  double dEndElev = dElev ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptP1, dEndElev)) {
                     m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                     return false ;
                  }
                  // aggiungo retrazione
                  if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ;
                     return false ;
                  }
               }
            }
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
                         double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // ciclo sulle regioni
   const int MAX_REGS = 50 ;
   int nReg = 0 ;
   while ( nReg < MAX_REGS) {

     // calcolo la spirale dall'interno all'esterno
      PtrOwner<ICurveComposite> pMCrv( CreateCurveComposite()) ;
      PtrOwner<ICurveComposite> pRCrv( CreateCurveComposite()) ;
      if ( IsNull( pMCrv)  ||  IsNull( pRCrv)) {
         m_pMchMgr->SetLastError( 2411, "Error in Pocketing : toolpath allocation failed") ;
         return false ;
      }

     // se lucidatura con epicicli
      if ( m_TParams.m_nType == TT_MILL_POLISHING && m_Params.m_dEpicyclesRad > EPS_SMALL ) {
        // verifico che parametri lucidatura siano sensati 
         if ( m_Params.m_dEpicyclesDist < 100 * EPS_SMALL) {
            m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
            return false ;
         }
        // modifico il diametro dell'utensile per tenere conto anche del raggio degli epicicli
         m_TParams.m_dDiam += 2 * m_Params.m_dEpicyclesRad ;
      }

      bool bOptimizedTrap = false ;
      if ( ! CalcSpiral( pCompo, nReg, bSplitArcs, pMCrv, pRCrv, nPathId, bOptimizedTrap))
         return false ;
     // se terminate le regioni, esco
      if ( pMCrv->GetCurveCount() == 0)
         break ;
      ++ nReg ;

      if ( m_TParams.m_nType == TT_MILL_POLISHING  &&  m_Params.m_dEpicyclesRad > EPS_SMALL) {
        // riporto il diametro dell'utensile al valore originale
         m_TParams.m_dDiam -= 2 * m_Params.m_dEpicyclesRad ;
        // aggiorno i percorsi di svuotatura con epicicli 
         if ( ! ComputePolishingPath( pMCrv, pRCrv, bSplitArcs)) {
            m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
            return false ;
         }
      }
   
     // nel caso ottimizzato verifico se posso entrare e uscire fuori dal grezzo 
      bool bOutStart = false ;
      int nOutsideRaw = 0 ;
      if ( bOptimizedTrap) {
         AdjustTrapezoidSpiralForLeadInLeadOut( pMCrv, pRCrv, vtTool, dDepth, nOutsideRaw) ;
         bOutStart = ( nOutsideRaw > 0) ;
      }

     // se utensile che non lavora di testa e ingresso non fuori dal pezzo, errore
      if ( m_TParams.m_nType == TT_MILL_NOTIP && ! bOutStart) {
         if ( ! LeadInRawIsOk()) { 
            m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
            return false ;
         }
      }

     // inverto i percorsi, perchè sono calcolati dall'esterno all'interno (solo nel caso non ottimizzato)
      if ( ! bOptimizedTrap) {
         pMCrv->Invert() ;
         pRCrv->Invert() ;
      }

     // determino numero e affondamento degli step
      int nStep = 1 ;
      nStep = max( 1, static_cast<int>( ceil( dElev / dOkStep))) ;
      double dStep = dElev / nStep ;
   
      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
      int nMaxRInd = pRCrv->GetCurveCount() - 1 ;
   
     // ciclo sugli step
      Point3d ptP1 ;
      for ( int j = 1 ; j <= nStep ; ++ j) {
        // se sono nel caso ottimizzato e ho attacco e uscita entrambi dentro/fuori dal grezzo, ad ogni step inverto la direzione della curva
         if ( bOptimizedTrap && nOutsideRaw != 1 && j > 1)
            pMCrv->Invert() ;
        // ciclo sulle curve elementari
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pMCrv->GetCurve( i) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
           // aggiungo affondamento
            pCurve->Translate( -vtTool * ( dDepth - dElev + j * dStep)) ;
           // se prima entità
            if ( i == 0 ) {
              // dati inizio entità
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               Vector3d vtStart ;
               pCurve->GetStartDir( vtStart) ;
              // se primo step, approccio e affondo
               if ( j == 1) {
                 // determino inizio attacco
                  if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, pRCrv, ptP1)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
                 // determino elevazione su inizio attacco
                  double dStElev ;
                  if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                     dStElev = dStep ;
                  bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                                     GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  bool bUhAboveRaw = ! m_bAboveHead  &&
                                     GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                         m_TParams.m_dLen, false, dSafeZ, vtTool, dStElev) ;
                  if ( bAhUnderRaw  ||  bUhAboveRaw  ||  m_bTiltingTab)
                     dStElev = max( dStElev, dStep) ;
                  dStElev -= ( ptP1 - ptStart) * vtExtr ;
                 // se attacco a zigzag o a spirale o a scivolo, l'elevazione va nell'attacco
                  if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
                       GetLeadInType() == POCKET_LI_HELIX  ||
                       GetLeadInType() == POCKET_LI_GLIDE) {
                     ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
                     dStElev = -LIO_ELEV_TOL ;
                  }
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, false)) {
                     m_pMchMgr->SetLastError( 2414, "Error in Pocketing : Approach not computable") ;
                     return false ;
                  }
                 // aggiungo attacco
                  SetFeed( GetStartFeed()) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, pRCrv, m_Params.m_bInvert, bSplitArcs, bOutStart)) {
                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
                     return false ;
                  }
               }
              // altrimenti solo collegamento
               else {
                  SetFeed( GetStartFeed()) ;
                  GetCurrPos( ptP1) ;
                  if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo, pRCrv, m_Params.m_bInvert, bSplitArcs, bOutStart)) {
                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
                     return false ;
                  }
               }
            }
           // elaborazioni sulla curva corrente
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               Point3d ptP3 = pLine->GetEnd() ;
               SetFeed( GetFeed()) ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
            else if ( pCurve->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCurve) ;
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ;
               pArc->GetEndPoint( ptP3) ;
               SetFeed( GetFeed()) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
           // se ultima entità
            if ( i == nMaxInd) {
              // se step intermedio
               if ( j < nStep) {
                 // se necessario ritorno all'inizio
                  if ( nMaxRInd >= 0) {
                    // copio la curva di ritorno
                     PtrOwner<ICurveComposite> pRet( pRCrv->Clone()) ;
                     if ( IsNull( pRet))
                        return false ;
                    // aggiungo affondamento
                     pRet->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
                    // se attacco a scivolo, accorcio della lunghezza dell'attacco
                     if ( GetLeadInType() == POCKET_LI_GLIDE) {
                        double dLen ; pRet->GetLength( dLen) ;
                        if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL)
                           pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang) ;
                        else
                           pRet->Clear() ;
                     }
                    // emetto
                     SetFeed( GetFeed()) ;
                     if ( pRet->GetCurveCount() > 0  &&  AddCurveMove( pRet) == GDB_ID_NULL)
                        return false ;
                  }
               }
              // atrimenti ultimo step, uscita e retrazione 
               else {
                 // dati fine entità
                  Point3d ptEnd ;
                  pCurve->GetEndPoint( ptEnd) ;
                  Vector3d vtEnd ;
                  pCurve->GetEndDir( vtEnd) ;
                 // aggiungo uscita
                  Point3d ptQ ;
                  double dEndElev = dElev ;
                  SetFeed( GetEndFeed()) ;
                  if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, pRCrv, bSplitArcs, false, ptQ, dEndElev)) {
                     m_pMchMgr->SetLastError( 2416, "Error in Pocketing : LeadOut not computable") ;
                     return false ;
                  }
                  // aggiungo retrazione
                  if ( ! AddRetract( ptQ, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dAppr, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2417, "Error in Pocketing : Retract not computable") ;
                     return false ;
                  }
               }
            }
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, 
                       ICurveComposite* pMCrv, ICurveComposite* pRCrv, int nPathId, bool& bOptimizedTrap)
{
  // inizializzo i risultati
   pMCrv->Clear() ;
   pRCrv->Clear() ;

  // primo offset pari al raggio utensile + sovramateriale
   double dTRad = 0.5 * m_TParams.m_dDiam ;
   double dOffs = dTRad + GetOffsR() ;

  // se circonferenza, chiamo la funzione specializzata
   Point3d ptCen ; Vector3d vtN ; double dRad ; bool bCCW ;
   if ( pCompo->IsACircle( 100 * EPS_SMALL, ptCen, vtN, dRad, bCCW)) {
      double dIntRad = 0 ;
      if ( m_Params.m_nSubType == POCKET_SUB_SPIRALOUT  &&  GetLeadInType() == POCKET_LI_HELIX) {
         dIntRad = min( 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam), dRad - dOffs) ;
         m_dMaxHelixRad = dIntRad ;
      }
      if ( nReg == 0)
         return CalcCircleSpiral( ptCen, vtN, dRad - dOffs, dIntRad, bSplitArcs, pMCrv, pRCrv) ;
      else
         return true ;
   }

  // recupero la curva originaria della svuotatura (non allargata per lati aperti) per verificare caso trapezoide 
   int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
   PtrOwner<ICurveComposite> pCrvPocket( CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId))) ;
   if ( IsNull( pCrvPocket))
      return false ;
   bool bSomeOpen ;
   SetCurveAllTempProp( nCrvId, GetForcedClosed(), pCrvPocket, &bSomeOpen) ;
   pCrvPocket->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;

   Point3d pt ;  
   Vector3d vtB1, vtL1, vtB2 ;
   if ( pCrvPocket->IsATrapezoid( 100 * EPS_SMALL, pt, vtB1, vtL1, vtB2)) {
      Vector3d vtDir( vtB1), vtOtherDir( vtL1) ;
     // se parallelogramma scelgo come base i lati lunghi
      Vector3d vtL2( -vtB1 + vtL1 + vtB2) ;
      if ( AreSameOrOppositeVectorApprox( vtL1, vtL2)) {
         if ( vtL1.Len() > vtB1.Len())
            swap( vtDir, vtOtherDir) ;
      }
      vtDir.Normalize() ;
      Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ;
      double dPocketSize = vtOrtho.Len() ;
      double dMaxOptSize = m_Params.m_dSideStep ;
      GetValInNotes( m_Params.m_sUserNotes, UN_MAXOPTSIZE, dMaxOptSize) ;
      if ( ( ( bSomeOpen  &&  dPocketSize < m_TParams.m_dDiam + EPS_SMALL)  ||  abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL)  &&
           dPocketSize < dMaxOptSize + 10 * EPS_SMALL) {
         if ( nReg == 0) {
            CalcTrapezoidSpiral( pCrvPocket, vtDir, dPocketSize, pMCrv, pRCrv, bOptimizedTrap) ;
            if ( bOptimizedTrap)
               return true ;
         }
         else
            return true ;
      }
   }

  // ciclo di offset verso l'interno
   const int MAX_ITER = 1000 ;
   int nIter = 0 ;
   ICURVEPOVECTOR vOffs ;
   ICURVEPOVECTOR vCrvStack ;
   DBLVECTOR vRadStack ;
   PtrOwner<ICurve> pOffs ;
   double dCurrRad = GetCurveRadius( pCompo) ;
   while ( nIter < MAX_ITER) {
     // se l'offset richiesto è pari al valore limite per la curva ne modifico leggermente il valore per evitare problemi con
     // le tolleranze di vroni   
      double dMaxOffs ;
      if ( nIter == 0)
         CalcCurveLimitOffset( *pCompo, dMaxOffs) ;
      else
         CalcCurveLimitOffset( *pOffs, dMaxOffs) ;
      if ( dOffs > dMaxOffs - 10 * EPS_ZERO  &&  dOffs < dMaxOffs + EPS_SMALL)
         dOffs = dMaxOffs - 10 * EPS_ZERO ;

     // calcolo
      OffsetCurve OffsCrv ;
      if ( ! OffsCrv.Make( ( nIter == 0 ? (ICurve*) pCompo : pOffs), - dOffs, ICurve::OFF_FILLET)  ||
           ( nIter == 0  &&  nReg == 0  &&  OffsCrv.GetCurveCount() == 0)) {
         m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
         return false ;
      }
     // se primo offset e richiesta regione oltre il massimo, esco
      if ( nIter == 0  &&  nReg >= OffsCrv.GetCurveCount())
         return true ;
     // recupero le curve di offset e le metto sullo stack (se primo offset solo quella voluta)
      int nCount = 0 ;
      ICurve* pCrv = OffsCrv.GetLongerCurve() ;
      while ( pCrv != nullptr) {
         if ( nIter != 0  ||  nReg == nCount) {
            vCrvStack.emplace_back( pCrv) ;
            vRadStack.emplace_back( dCurrRad) ;
            if ( nIter == 0)
               break ;
         }
         else
            delete( pCrv) ;
         pCrv = OffsCrv.GetCurve() ;
         ++ nCount ;
      }
     // recupero la prossima curva di offset
      PtrOwner<ICurve> pNextOffs ;
      if ( ! vCrvStack.empty()) {
         pNextOffs.Set( vCrvStack.back()) ;
         vCrvStack.pop_back() ;
         dCurrRad = vRadStack.back() ;
         vRadStack.pop_back() ;
      }
      double dRad = GetCurveRadius( pNextOffs) ;
      bool bNextOk = ( dRad > EPS_ZERO  &&  dRad < dCurrRad) ;
      bool bSmallRad = ( nIter == 0 ? dOffs < dTRad + GetOffsR() + EPS_ZERO : dOffs < dTRad + EPS_ZERO) ;
     // se completato step di offset, accodo la curva offsettata al percorso di lavoro 
      if ( ! IsNull( pOffs)  &&  ( bNextOk  ||  bSmallRad)) {
        // inserisco l'offset nel vettore
         vOffs.emplace_back( Release( pOffs)) ;
      }
     // se offset va bene
      if ( bNextOk) {
        // sistemo per prossimo step
         dCurrRad = dRad ;
         pOffs.Set( pNextOffs) ;
        // nuovo valore pari allo step
         dOffs = GetSideStep() ;
      }
     // se altrimenti riducibile, provo con offset ridotto al raggio utensile
      else if ( ! bSmallRad) {
        // nuovo valore pari al raggio
         dOffs = ( nIter == 0 ? dTRad + GetOffsR() : dTRad) ;
      }
     // altrimenti esco
      else 
         break ;
     // incremento contatore iterazioni
      ++ nIter ;
   } 

  // calcolo i collegamenti
   ICURVEPOVECTOR vLinks( vOffs.size()) ;
   for ( int i = 1 ; i < int( vOffs.size()) ; ++ i) {
     // punti di inizio e fine 
      Point3d ptStart ;
      vOffs[i-1]->GetEndPoint( ptStart) ;
      Point3d ptEnd ;
      vOffs[i]->GetStartPoint( ptEnd) ;
     // calcolo il collegamento (garantendo che non esca dalla svuotatura)
      PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
      if ( CalcBoundedLink( ptStart, ptEnd, vOffs[0], pCrvLink)) 
         vLinks[i].Set( pCrvLink) ;
      else {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }
   }

  // calcolo il percorso di ritorno
   if ( vOffs.size() >= 2) {
     // punti di inizio e fine
      Point3d ptStart ;
      vOffs.back()->GetEndPoint( ptStart) ;
      Point3d ptEnd ;
      vOffs.front()->GetStartPoint( ptEnd) ;
     // calcolo il ritorno (garantendo che non esca dalla svuotatura)
      PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
      if ( CalcBoundedLink( ptStart, ptEnd, vOffs[0], 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 Pocketing : Linear Approx not computable") ;
            return false ;
         }
         VerifyArcs( pRCrv) ;
      }
      else {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
         return false ;
      }
   }

  // creo il percorso di lavoro a partire dalla raccolta degli offset e dei collegamenti
   for ( int i = 0 ; i < int( vOffs.size()) ; ++ i) {
     // se collegamento da aggiungere
      if ( ! IsNull( vLinks[i])) {
         int nCrvsCount0 = pMCrv->GetCurveCount() ;
        // accodo nel percorso di lavorazione
         pMCrv->AddCurve( Release( vLinks[i])) ;
        // nel caso di lucidatura setto proprietà alle curve di collegamento per poterle identificare 
         if ( m_TParams.m_nType == TT_MILL_POLISHING) {
            for ( int j = nCrvsCount0 ; j < pMCrv->GetCurveCount() ; j ++)
               pMCrv->SetCurveTempProp( j, LINK_CURVE_PROP) ;
         }
      }
     // se richiesta percorrenza invertita
      if ( m_Params.m_bInvert)
         vOffs[i]->Invert() ;
     // aggiungo la curva
      pMCrv->AddCurve( Release( vOffs[i])) ;
   }

  // verifico il percorso di lavoro
   if ( pMCrv->GetCurveCount() == 0) {
      m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
      return false ;
   }
  // se necessario, approssimo archi con rette
   if ( bSplitArcs  &&  ! ApproxWithLines( pMCrv)) {
      m_pMchMgr->SetLastError( 2419, "Error in Pocketing : Linear Approx not computable") ;
      return false ;
   }
  // eventuale sistemazione archi
   VerifyArcs( pMCrv) ;

  // setto estrusione
   Vector3d vtExtr ;
   if ( pCompo->GetExtrusion( vtExtr))
      pMCrv->SetExtrusion( vtExtr) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, const ICurve* pCrvBound,
                            ICurveComposite* pCrvLink)
{   
  // recupero il vettore estrusione
   Vector3d vtExtr ;
   pCrvBound->GetExtrusion( vtExtr) ;
  // determino il riferimento naturale della svuotatura (OCS con il vettore estrusione come asse Z)
   Frame3d frLoc ;
   frLoc.Set( ORIG, vtExtr) ;
  // porto la curva di contenimento in locale a questo riferimento
   CurveLocal CrvOutLoc( pCrvBound, GLOB_FRM, frLoc) ;

  // creo la retta che li unisce
   PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
   if ( IsNull( pLine)  ||  ! pLine->Set( ptStart, ptEnd))
      return false ;
   pLine->SetExtrusion( vtExtr) ;
  // la porto in locale al riferimento della svuotatura
   CurveLocal LineLoc( pLine, GLOB_FRM, frLoc) ;

  // classifico la curva di collegamento rispetto a quella di contenimento
   CRVCVECTOR ccClass ;
   IntersCurveCurve intCC( *LineLoc, *CrvOutLoc) ;
   intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
  // se nessuno o un solo tratto e interno, la retta è il collegamento
   if ( ccClass.empty()  ||  ( ccClass.size() == 1  &&  ccClass[0].nClass == CRVC_IN)) {
      pCrvLink->AddCurve( Release( pLine)) ;
      return true ;
   }
  // altrimenti combino i tratti interni di retta con tratti opportuni della curva di contenimento
   else {
      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
      if ( IsNull( pCompo))
         return false ;
      for ( int j = 0 ; j < int( ccClass.size()) ; ++ j) {
         if ( ccClass[j].nClass == CRVC_IN  ||  ccClass[j].nClass == CRVC_ON_P  ||  ccClass[j].nClass == CRVC_ON_M)
            pCompo->AddCurve( pLine->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ;
         else if ( ccClass[j].nClass == CRVC_OUT) {
            Point3d ptS ;
            pLine->GetPointD1D2( ccClass[j].dParS, ICurve::FROM_PLUS, ptS) ;
            double dOffS ;
            pCrvBound->GetParamAtPoint( ptS, dOffS) ;
            Point3d ptE ;
            pLine->GetPointD1D2( ccClass[j].dParE, ICurve::FROM_MINUS, ptE) ;
            double dOffE ;
            pCrvBound->GetParamAtPoint( ptE, dOffE) ;
           // recupero i due possibili percorsi e uso il più corto
            PtrOwner<ICurve> pCrvA( pCrvBound->CopyParamRange( dOffS, dOffE)) ;
            PtrOwner<ICurve> pCrvB( pCrvBound->CopyParamRange( dOffE, dOffS)) ;
            if ( IsNull( pCrvA)  ||  IsNull( pCrvB))
               return false ;
            double dLenA ; pCrvA->GetLength( dLenA) ;
            double dLenB ; pCrvB->GetLength( dLenB) ;
            if ( dLenA < dLenB) {
               pCompo->AddCurve( Release( pCrvA)) ;
            }
            else {
               pCrvB->Invert() ;
               pCompo->AddCurve( Release( pCrvB)) ;
            }
         }
      }
      pCrvLink->AddCurve( Release( pCompo)) ;
      return true ;
   }
}

//------------------------------------------------------------------------------
bool 
Pocketing::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
Pocketing::CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double dOutRad, double dIntRad,
                             bool bSplitArcs, ICurveComposite* pMCrv, ICurveComposite* pRCrv)
{
  // raggio della circonferenza esterna
   if ( dOutRad < 10 * EPS_SMALL) {
      m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
      return false ;
   }

  // imposto versore estrusione sulle curve composite
   pMCrv->SetExtrusion( vtN) ;
   pRCrv->SetExtrusion( vtN) ;

  // creo e inserisco la circonferenza esterna
   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
   if ( IsNull( pArc)  ||  ! pArc->Set( ptCen, vtN, dOutRad)) {
      m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
      return false ;
   }
   Vector3d vtDir = pArc->GetStartVersor() ;
   pMCrv->AddCurve( Release( pArc)) ;
  // se richiesta percorrenza invertita
   if ( m_Params.m_bInvert)
      pMCrv->Invert() ;

  // se raggio esterno maggiore dell'interno
   if ( dOutRad > dIntRad + 10 * EPS_SMALL) {

     // aggiungo le semicirconferenze della spirale ( devono essere in numero dispari)
      int nStep = int( ceil( ( dOutRad - dIntRad) / ( 0.5 * GetSideStep()))) ;
      if ( IsEven( nStep))
         nStep += 1 ;
      double dStep = ( dOutRad - dIntRad) / nStep ;
      for ( int i = 1 ; i <= nStep ; ++ i) {
         if ( ! IsEven( i))
            pMCrv->AddArcTg( ptCen - vtDir * ( dOutRad - i * dStep)) ;
         else
            pMCrv->AddArcTg( ptCen + vtDir * ( dOutRad - i * dStep)) ;
      }

     // aggiungo la circonferenza interna
      pMCrv->AddArcTg( ptCen + vtDir * dIntRad) ;
      pMCrv->AddArcTg( ptCen - vtDir * dIntRad) ;
   }

  // verifico il percorso di lavoro
   if ( pMCrv->GetCurveCount() == 0) {
      m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;
      return false ;
   }
  // se necessario, approssimo con rette
   if ( bSplitArcs  &&  ! ApproxWithLines( pMCrv)) {
      m_pMchMgr->SetLastError( 2419, "Error in Pocketing : Linear Approx not computable") ;
      return false ;
   }
  // eventuale sistemazione archi
   VerifyArcs( pMCrv) ;

  // calcolo l'eventuale percorso di ritorno
   Point3d ptStart ; pMCrv->GetStartPoint( ptStart) ;
   Point3d ptEnd ; pMCrv->GetEndPoint( ptEnd) ;
   Vector3d vtStart ; pMCrv->GetStartDir( vtStart) ;
   if ( ! AreSamePointApprox( ptStart, ptEnd)) {
      PtrOwner<ICurveArc> pArc2( CreateCurveArc()) ;
      if ( IsNull( pArc2)  ||  ! pArc2->Set2PVN( ptStart, ptEnd, - vtStart, vtN)) {
         m_pMchMgr->SetLastError( 2420, "Error in Pocketing : Return toolpath not computable") ;
         return false ;
      }
      pRCrv->AddCurve( Release( pArc2)) ;
     // inverto
      pRCrv->Invert() ;
     // se necessario, approssimo con rette
      if ( bSplitArcs  &&  ! ApproxWithLines( pRCrv)) {
         m_pMchMgr->SetLastError( 2419, "Error in Pocketing : Linear Approx not computable") ;
         return false ;
      }
     // eventuale sistemazione archi
      VerifyArcs( pRCrv) ;
   }

   return true ;
}

//----------------------------------------------------
bool
Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtDir, double dPocketSize,
                                ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap)
{
   bOptimizedTrap = false ;

   Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ;
  // eventuale approssimazione della curva con polyline per ottenere la stessa curva calcolata in ICurveComposite::IsATrapezoid
   if ( pCrvPocket->GetCurveCount() > 4) {
      PolyLine PL ;
      if ( ! pCrvPocket->ApproxWithLines( 100 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
         return false ;
      pCrvPocket->Clear() ;
      pCrvPocket->FromPolyLine( PL) ;
      pCrvPocket->SetExtrusion( vtExtr) ;
   }

  // sistemo senso antiorario visto dalla direzione di estrusione
   Plane3d plPlane ; double dArea ;
   pCrvPocket->GetArea( plPlane, dArea) ;
   if ( plPlane.GetVersN() * vtExtr * dArea < 0)
      pCrvPocket->Invert() ;

  // passo in un sistema di riferimento locale avente asse X allineato con uno dei due lati paralleli (possibilmente aperto) e centro nel
  // punto iniziale del lato 
   Frame3d frLoc ;
   if ( ! CalcTrapezoidSpiralLocalFrame( pCrvPocket, vtDir, frLoc))
      return false ;  
   pCrvPocket->ToLoc( frLoc) ;

  // recupero flag aperto/chiuso dei lati (0=chiuso, 1=aperto)
   INTVECTOR vnProp( 4, 0) ;
   for ( int i = 0 ; i < 4 ; i++)
      pCrvPocket->GetCurveTempProp( i, vnProp[i]) ;

  // verifico le dimensioni della svuotatura
   double dLen0 = 0, dLen2 = 0 ;
   pCrvPocket->GetCurve( 0)->GetLength( dLen0) ;
   pCrvPocket->GetCurve( 2)->GetLength( dLen2) ;
   if ( vnProp[0] == 0  &&  abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL)
      return false ;
   if ( vnProp[1] == 0  &&  vnProp[3] == 0) {
      if ( dLen0 < m_TParams.m_dDiam - EPS_SMALL || dLen2 < m_TParams.m_dDiam - EPS_SMALL)
         return false ;
   }

  // calcolo la larghezza massima della svuotatura (riferimento con X parallelo a primo lato chiuso)
   Point3d ptOrig ;
   pCrvPocket->GetCurve( 1)->GetStartPoint( ptOrig) ;
   Vector3d vtX ;
   pCrvPocket->GetCurve( 1)->GetStartDir( vtX) ;
   Frame3d frDim ; frDim.Set( ptOrig, Z_AX, vtX) ; frDim.Invert() ;
   BBox3d b3Dim ;
   pCrvPocket->GetBBox( frDim, b3Dim, BBF_EXACT) ;
   double dMaxLarg = b3Dim.GetDimY() ; 

  // calcolo percorso di svuotatura 
  // se lati obliqui sono entrambi chiusi e dimensione svuotatura è maggiore di diametro fresa e minore del doppio gestione speciale
   if ( vnProp[0] != 0  &&  vnProp[2] != 0  &&  vnProp[3] == 0  &&  vnProp[1] == 0  &&
        dMaxLarg > m_TParams.m_dDiam + 10 * EPS_SMALL  &&  max( dLen0, dLen2) < 2 * m_TParams.m_dDiam + EPS_SMALL) {
      if ( ! SpecialAdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket)) {
         pMCrv->Clear() ;
         return false ;
      }
   }
   else {
      double dYCoord = dPocketSize - 0.5 * m_TParams.m_dDiam ;
      if ( vnProp[0] != 0) 
         dYCoord -= GetOffsR() ; 
      if ( vnProp[0] != 0  &&  vnProp[2] != 0)
         dYCoord = 0.5 * dPocketSize ;   // se entrambi i lati paralleli sono aperti mi posiziono a metà della svuotatura 

      double dXCoordStart, dXCoordEnd ; 
      if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, true, dYCoord, dXCoordStart, dPocketSize)) 
         return false ;
      if ( ! CalcTrapezoidSpiralXCoord( pCrvPocket, false, dYCoord, dXCoordEnd, dPocketSize))
         return false ;
      if ( dXCoordStart > dXCoordEnd + 500 * EPS_SMALL)
         return false ;
      Point3d ptStart( dXCoordStart, dYCoord) ;
      Point3d ptEnd( dXCoordEnd, dYCoord) ;

      if ( AreSamePointEpsilon( ptStart, ptEnd, 500 * EPS_SMALL)  &&  vnProp[0] != 0) {
         Vector3d vtDir1, vtDir3 ; 
         pCrvPocket->GetCurve( 1)->GetStartDir( vtDir1) ;
         pCrvPocket->GetCurve( 3)->GetStartDir( vtDir3) ;
        // gestisco il caso speciale di un parallelogramma in cui anche l'altra dimensione della svuotatura è pari al diametro utensile
         if ( AreOppositeVectorApprox( vtDir1, vtDir3)) {
            PtrOwner<ICurveLine> pLine1( GetCurveLine( pCrvPocket->GetCurve( 1)->Clone())) ;
            PtrOwner<ICurveLine> pLine3( GetCurveLine( pCrvPocket->GetCurve( 3)->Clone())) ;
            if ( IsNull( pLine1) || IsNull( pLine3))
               return true ;
            if ( ! pLine1->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ||
                 ! pLine3->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()))
               return true ;

            Point3d ptS, ptE ;
            if ( vtDir3 * X_AX > EPS_SMALL) {
               pLine1->GetStartPoint( ptS) ;
               pLine3->GetStartPoint( ptE) ;
            }
            else {
               pLine1->GetEndPoint( ptE) ;
               pLine3->GetEndPoint( ptS) ;
            }

            pMCrv->AddPoint( ptS) ;
            if ( vnProp[2] != 0)
               pMCrv->AddLine( ptE) ;
            else 
               pMCrv->AddLine( ptStart) ;

            pMCrv->SetCurveTempProp( 0, 1) ;
         }
      }
      else {
         if ( ! pMCrv->AddPoint( ptStart)) 
            return true ;
         if ( ! pMCrv->AddLine( ptEnd))
            return true ;

        // aggiustamenti al percorso per rimuovere materiale residuo negli angoli
         if ( vnProp[0] != 0) {
            if ( vnProp[3] == 0  &&  ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, true)) {
               pMCrv->Clear() ;
               return false ;
            }
            if ( vnProp[1] == 0  &&  ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, false)) {
               pMCrv->Clear() ;
               return false ;
            }
         }
      }
   }

   if ( pMCrv->GetCurveCount() == 0)
      return true ;

   pMCrv->ToGlob( frLoc) ;
   if ( ! m_Params.m_bInvert) {
      pMCrv->Invert() ;
     // inverto le proprietà in modo che nProp3 sia sempre legata al punto iniziale e nProp1 a quello finale
      swap( vnProp[1], vnProp[3]) ;
   }
  // segno i lati aperti come temp prop della curva  
   int nOpenEdges = vnProp[0] + vnProp[1] * 2 + vnProp[3] * 8 ;
   pMCrv->SetTempProp( nOpenEdges, 0) ;
   pMCrv->SetExtrusion( vtExtr) ;

   bOptimizedTrap = true ;
   return true ;
}

//----------------------------------------------------
bool
Pocketing::CalcTrapezoidSpiralLocalFrame( ICurveComposite* pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc)
{
  // cerco i lati paralleli a vtDir
   int nBaseId = -1 ;
   for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
      Vector3d vtEdge ;
      pCrvPocket->GetCurve( i)->GetStartDir( vtEdge) ;
      if ( AreSameOrOppositeVectorApprox( vtEdge, vtDir)) {
         nBaseId = i ;
         break ;
      }
   }
   if ( nBaseId != 0  &&  nBaseId != 1)
      return false ;

  // imposto come lato iniziale per la curva uno dei lati paralleli a vtDir (possibilmente aperto)
   int nProp0, nProp2 ;
   pCrvPocket->GetCurveTempProp( nBaseId, nProp0) ;
   pCrvPocket->GetCurveTempProp( nBaseId + 2, nProp2) ;
   if ( nProp0 == 0  &&  nProp2 != 0)
      pCrvPocket->ChangeStartPoint( nBaseId + 2) ;
   else
      pCrvPocket->ChangeStartPoint( nBaseId) ;

   Point3d ptOrig ; 
   pCrvPocket->GetStartPoint( ptOrig) ;
   Vector3d vtExtr ; 
   pCrvPocket->GetExtrusion( vtExtr) ;
   Vector3d vtX ; 
   pCrvPocket->GetStartDir( vtX) ;
   return frLoc.Set( ptOrig, vtExtr, vtX) ;
}

//------------------------------------------------------
bool 
Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite* pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize)
{
  // se open 
   int nCrvId = ( bStart ? 3 : 1) ;
   int nProp ;
   if ( pCrvPocket->GetCurveTempProp( nCrvId, nProp)  &&  nProp != 0) {
      Point3d pt1, pt2 ;
      pCrvPocket->GetCurve( nCrvId)->GetStartPoint( pt1) ;
      pCrvPocket->GetCurve( nCrvId)->GetEndPoint( pt2) ;
      if ( bStart)
         dXCoord = min( pt1.x, pt2.x) ;
      else
         dXCoord = max( pt1.x, pt2.x) ;  
   }
  // se closed 
   else {
      double dRad = 0.5 * m_TParams.m_dDiam + GetOffsR() ;
      double dVal ; 
      Vector3d vtRef ; 
      pCrvPocket->GetCurve( nCrvId)->GetStartDir( vtRef) ;
      double dCosAlpha = vtRef * X_AX ;
      
      if ( dRad * dCosAlpha < dYCoord && dYCoord < dPocketSize + dRad * dCosAlpha) {
         double dSinAlpha = ( vtRef ^ X_AX).Len()  ;
         if ( abs( dSinAlpha) <  EPS_SMALL) 
            return false ;
         dVal = 1.0 / dSinAlpha * ( dRad - dYCoord * dCosAlpha) ;
      }
      else if ( dYCoord < dRad * dCosAlpha)
         dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ;
      else {
         double dLen ;
         pCrvPocket->GetCurve( nCrvId)->GetLength( dLen) ;
         dVal = - dLen * dCosAlpha + sqrt( dRad * dRad - dYCoord * dYCoord) ;
      }

      Point3d ptRef ;
      if ( bStart) {
         pCrvPocket->GetCurve( nCrvId)->GetEndPoint( ptRef) ;
         dXCoord = ptRef.x + dVal ;
      }
      else {
         pCrvPocket->GetCurve( nCrvId)->GetStartPoint( ptRef) ; 
         dXCoord = ptRef.x - dVal ;
      }
   }
   return true ;
}

//----------------------------------------------------
bool
Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveComposite* pCrvPocket, bool bStart)
{
   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
   if ( ! bStart)
      pMCrv->Invert() ;

   Point3d ptTmp ;
   pMCrv->GetStartPoint( ptTmp) ;
   double dYCoord = ptTmp.y ;     // quota verticale del percorso di svuotatura
   pCrvPocket->GetCurve( 2)->GetStartPoint( ptTmp) ;
   double dPocketSize = ptTmp.y ;

   int nCrvId = ( bStart ? 3 : 1) ;
   PtrOwner<ICurveLine> pLine( GetCurveLine( pCrvPocket->GetCurve( nCrvId)->Clone())) ;
   pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ;

   Point3d ptP1, ptP2 ;
   pLine->GetStartPoint( ptP1) ;
   pLine->GetEndPoint( ptP2) ;
   if ( ! bStart)
      swap( ptP1, ptP2) ;

   int nProp2 ;
  // lato opposto a quello di riferimento aperto 
   if ( pCrvPocket->GetCurveTempProp( 2, nProp2)  &&  nProp2 != 0) {

     // caso 1 : pLine ha un estremo sopra e uno sotto il percorso di svuotatura pMCrv
      if ( ptP2.y < dYCoord  &&  dYCoord < ptP1.y) {

        // creo tratto da ptP2 a ptP1
         pCompo->AddPoint( ptP2) ;
         pCompo->AddLine( ptP1) ;

        // trovo il punto di pMCrv da cui ripartire per non lasciare aree residue 
         pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam) ;
         pLine->ExtendStartByLen( EPS_SMALL) ;
         pLine->ExtendEndByLen( EPS_SMALL) ;
         IntersCurveCurve intCC( *pLine, *pCrvPocket) ;
         if ( intCC.GetIntersCount() == 0)
            return false ;
         IntCrvCrvInfo aInfo ;
         intCC.GetIntCrvCrvInfo( 0, aInfo) ;
         double dDeltaX = sqrt( m_TParams.m_dDiam * m_TParams.m_dDiam / 4 - dYCoord * dYCoord) ;
         if ( ! bStart) 
            dDeltaX *= -1 ;
         Point3d ptCrv( aInfo.IciA[0].ptI.x + dDeltaX, dYCoord) ;

         double dPar = 0 ; 
         if ( ! pMCrv->GetParamAtPoint( ptCrv, dPar)) {
            dPar = 0.5 ;
            pMCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptCrv) ;
         }
         pMCrv->TrimStartAtParam( dPar) ;
        
         if ( ptP1.y > dPocketSize) {
           // se ptP1 è esterno alla svuotatura scambio i punti in modo da usare ptP2 per il biarco ( così da non farlo fuoriuscire troppo)
            swap( ptP1, ptP2) ;
            pCompo->Invert() ;
         }

        // creo biarco fra ptP1 e ptCrv
         Vector3d vtDir ;
         pCompo->GetStartDir( vtDir) ;
         double dAng ;
         vtDir.GetAngleXY( X_AX, dAng) ;
         PtrOwner<ICurve> pBiArc( GetBiArc( ptP1, - dAng, ptCrv, bStart ? 0 : 180, 0.8)) ;
         
         bool bUseBiArc = false ;
         if ( ! IsNull( pBiArc)) {
           // verifico che con il biarco non si oltrepassi il lato obliquo chiuso della svuotatura  
            IntersCurveCurve intCC2( *pBiArc, *pCompo) ;
            if ( intCC2.GetIntersCount() == 1)
               bUseBiArc = true ;
         }
         if ( bUseBiArc)
            pCompo->AddCurve( Release( pBiArc)) ;
         else {
            double dParLine = ( dYCoord - ptP2.y) / ( ptP1.y - ptP2.y) ;
            Point3d ptOnLine = Media( ptP2, ptP1, dParLine) ;
            pCompo->AddLine( ptOnLine) ;
            pCompo->AddLine( ptCrv) ;
         }
      }

     // caso 2 : pLine è completamente sopra/sotto la linea di svuotatura
      else {
        // se è sopra modifiche per ricondurmi al caso in cui è sotto 
         if ( ptP2.y > dYCoord) {
            pLine->Invert() ;
            swap( ptP1, ptP2) ;
         }

        // trovo l'intersezione fra il prolungamento della linea e pMCrv
         if ( bStart)
            pLine->ExtendStartByLen( 1000) ;
         else
            pLine->ExtendEndByLen( 1000) ;
         IntersCurveCurve intCC ( *pLine, *pMCrv) ;
         if ( intCC.GetIntersCount() == 0)
            return false ;
         IntCrvCrvInfo aInfo ;
         intCC.GetIntCrvCrvInfo( 0, aInfo) ;
         Point3d ptInt ;
         ptInt = aInfo.IciA[0].ptI ;
         double dPar = 0 ;
         pMCrv->GetParamAtPoint( ptInt, dPar) ;
         pMCrv->TrimStartAtParam( dPar) ;

         pCompo->AddPoint( ptP2) ;
         pCompo->AddLine( ptInt) ;
      }
   }

  // se il lato opposto a quello di riferimento è chiuso bisogna distinguere i casi
   else {
      bool bStartPnt = false ;
      if ( ptP2.y < dYCoord) {
         bStartPnt = pCompo->AddPoint( ptP2) ;
      }
      else {
         Vector3d vtDir ;
         pLine->GetStartDir( vtDir) ;
         if ( bStart)
            vtDir.Invert() ;
         Point3d ptP2N = ptP2 - m_TParams.m_dDiam / 2 * abs( vtDir.x / vtDir.y) * vtDir  ;
         if ( ptP2N.y < dYCoord)
            bStartPnt = pCompo->AddPoint( ptP2N) ;
      }
      if ( bStartPnt) {
         Point3d ptCrv ;
         pMCrv->GetStartPoint( ptCrv) ;
         pCompo->AddLine( ptCrv) ;
      }
   }

  // setto temp prop per ricordare che è curva aggiuntiva per pulire angoli
   for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++)
      pCompo->SetCurveTempProp( i, 1) ;

   pMCrv->AddCurve( Release( pCompo), false) ;
   if ( ! bStart) 
      pMCrv->Invert() ;   // ripristino la direzione originaria

   return true ;
}

//----------------------------------------------------
bool
Pocketing::SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveComposite* pCrvPocket)
{
  // calcolo gli offset dei lati obliqui
   PtrOwner<ICurveLine> pLineS( GetCurveLine( pCrvPocket->GetCurve( 3)->Clone())) ;
   pLineS->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ;
   pLineS->Invert() ;
   PtrOwner<ICurveLine> pLineE( GetCurveLine( pCrvPocket->GetCurve( 1)->Clone())) ;
   pLineE->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ;
   pLineE->Invert() ;

   Point3d ptS, ptE ;
   pLineS->GetEndPoint( ptS) ;
   pLineE->GetStartPoint( ptE) ;
   Vector3d vtS, vtE ;
   pLineS->GetStartDir( vtS) ;
   pLineE->GetStartDir( vtE) ;

   PtrOwner<ICurveLine> pLineLink( CreateCurveLine()) ;
   pLineLink->Set( ptS, ptE) ;

   pMCrv->Clear() ;
   if ( ! pMCrv->AddCurve( Release( pLineS)))
      return false ;

  // creo raccordi
   bool bUseBiArcs = false ;
   Vector3d vtDir, vtDir2 ; 
   pLineLink->GetStartDir( vtDir) ;
   pCrvPocket->GetStartDir( vtDir2) ;

   if ( Dist( ptS, ptE) > 500 * EPS_SMALL  &&  AreSameOrOppositeVectorApprox( vtDir, vtDir2)) {
       
      Point3d ptCrv1, ptCrv2 ;
      pLineLink->GetPointD1D2( 0.3, ICurve::FROM_MINUS, ptCrv1) ;
      pLineLink->GetPointD1D2( 0.7, ICurve::FROM_MINUS, ptCrv2) ;

     // primo raccordo
      double dAng ;
      vtS.GetAngleXY( X_AX, dAng) ;
      PtrOwner<ICurve> pBiArc1( GetBiArc( ptS, - dAng, ptCrv1, 0, 0.5)) ;

     // secondo raccordo
      vtE.GetAngleXY( X_AX, dAng) ;
      PtrOwner<ICurve> pBiArc2( GetBiArc( ptE, dAng, ptCrv2, 180, 0.5)) ;
      pBiArc2->Invert() ; 

      if ( ! IsNull( pBiArc1)  &&  ! IsNull( pBiArc2)) {
         bUseBiArcs = true ;
         pMCrv->AddCurve( Release( pBiArc1)) ;
         pMCrv->AddLine( ptCrv2) ;
         pMCrv->AddCurve( Release( pBiArc2)) ;
      }
   }

  // se non è stato possibile creare raccordo, unisco linearmente
   if ( ! bUseBiArcs) 
      pMCrv->AddCurve( Release( pLineLink)) ;

   if ( ! pMCrv->AddCurve( Release( pLineE)))
      return false ;

  // setto temp prop per ricordare curve aggiuntive per pulire angoli
   pMCrv->SetCurveTempProp( 0, 1) ;
   pMCrv->SetCurveTempProp( pMCrv->GetCurveCount() - 1, 1) ;

   return true ;
}

//----------------------------------------------------
bool
Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, ICurveComposite* pRCrv, const Vector3d& vtTool, double dDepth,
                                                  int& nOutsideRaw)
{
  // recupero la direzione principale della svuotatura  
   Vector3d vtMainDir ;
   for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) {
      int nProp ;
      if ( pCompo->GetCurveTempProp( i, nProp)  &&  nProp == 0) {
        // se non è lato aggiuntivo per la pulitura angoli recupero la sua direzione
         pCompo->GetCurve( i)->GetStartDir( vtMainDir) ;
         break ;
      }
   }

  // start point
   bool bStartOutside = false ;
   ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, true, vtTool, dDepth, bStartOutside) ;
  // end point
   bool bEndOutside = false ;
   ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, false, vtTool, dDepth, bEndOutside) ; 

  // eventuale inversione della curva per partire sempre dall'esterno del grezzo 
   if ( bEndOutside  &&  ! bStartOutside)
      pCompo->Invert() ;

   nOutsideRaw = 0 ;
   if ( bStartOutside  &&  bEndOutside)
      nOutsideRaw = 2 ;
   else if ( bStartOutside  ||  bEndOutside) {
      nOutsideRaw = 1 ;

     // calcolo percorso di ritorno
      pRCrv->Clear() ;
      pRCrv->AddCurve( pCompo->Clone()) ;
      pRCrv->Invert() ;
   }

   return true ;
}

//----------------------------------------------------
bool
Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite* pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw)
{
   bIsOutsideRaw = false ;

   Point3d ptP ;
   Vector3d vtDir ;
   if ( bLeadIn) {
      pCompo->GetStartPoint( ptP) ;
      pCompo->GetStartDir( vtDir) ;
   }
   else {
      pCompo->GetEndPoint( ptP) ;
      pCompo->GetEndDir( vtDir) ;
   }
   Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;

  // recupero info sui lati aperti 
   int nPropOpen = pCompo->GetTempProp( 0) ;
   bool bEdgeOpen = (( nPropOpen & ( bLeadIn ? 8 : 2)) > 0) ;
   bool bBaseOpen = (( nPropOpen & 1) > 0) ;
  
  // recupero info per capire se sto considerando un lato aggiuntivo per pulire angoli
   int nIdCrv = ( bLeadIn ? 0 : pCompo->GetCurveCount() - 1) ;
   int nExtraEdge ;
   pCompo->GetCurveTempProp( nIdCrv, nExtraEdge) ;

   double dSafeZ = GetSafeZ() ;

  // tento con allungamento se lato inclinato è aperto oppure se sto considerando un lato aggiuntivo per pulire angoli
   if ( bEdgeOpen  ||  nExtraEdge == 1) {

      Vector3d vtDirP = ( bLeadIn ? -vtDir : vtDir) ;

     // se forzato come fuori dal grezzo
      if ( m_bOpenOutRaw) {
         Point3d ptNewStart = ptP + vtDirP * ( m_TParams.m_dDiam / 2 + max( dSafeZ, m_dOpenMinSafe)) ;
         pCompo->AddLine( ptNewStart, ! bLeadIn) ;
         bIsOutsideRaw = true ;
         return true ;
      }

     // recupero la distanza dal bordo del grezzo lungo la direzione di allungamento
      double dDist ;
      Vector3d vtNorm ;
      if ( ! CalcDistanceFromRawSurface( m_nPhase, ptP, vtDirP, dDist, vtNorm))
         return false ;
      if ( abs( dDist) < EPS_SMALL) {
         ptP -= vtDirP ;
         if ( ! CalcDistanceFromRawSurface( m_nPhase, ptP, vtDirP, dDist, vtNorm))
            return false ;
      }

     // calcolo eventuali fattori correttivi (se uscita approx. con fianco utensile)
      double dCorr = 1 ;
      double dDistRef = dDist ;
      double dDistMin ;
      Vector3d vtNormMin ;
      if ( abs( vtTool * vtNorm) < 0.5  &&  CalcDistanceFromRawSurface( m_nPhase, ptP, vtNorm, dDistMin, vtNormMin)) {
         if ( abs( dDistMin) < abs( dDist)  &&  abs( dDistMin) > EPS_SMALL) {
            dDistRef = dDistMin ;
            dCorr = dDist / dDistMin ;
         }
      }

     // se vicino al bordo del grezzo 
      if ( dDistRef < m_TParams.m_dDiam / 2 + EPS_SMALL) {
         Point3d ptTest = ptP + vtDirP * ( dDist + ( m_TParams.m_dDiam / 2 + max( dSafeZ, m_dOpenMinSafe)) * dCorr) ;
         ptTest += - vtTool * dDepth ;
         double dTestElev ;
        // se è fuori dal grezzo 
         if ( ! GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElev)  ||  dTestElev < EPS_SMALL) {
            Point3d ptNewStart = ptP + vtDirP * ( dDist + ( m_TParams.m_dDiam / 2 + max( dSafeZ, m_dOpenMinSafe)) * dCorr) ;
            pCompo->AddLine( ptNewStart, ! bLeadIn) ;
            bIsOutsideRaw = true ;
         }
      }
   }

  // tento con attacco ruotato di 90° se non sto considerando un tratto aggiuntivo per pulire angoli
   if ( bBaseOpen  &&  ! bIsOutsideRaw  &&  nExtraEdge == 0) {

      Vector3d vtDirO = vtDir ;
      vtDirO.Rotate( vtExtr, ( m_Params.m_bInvert ? -90 : 90)) ;
     // calcolo distanza dal bordo del grezzo lungo vtDirO
      double dDist ;
      Vector3d vtNorm ;
      if ( ! CalcDistanceFromRawSurface( m_nPhase, ptP, vtDirO, dDist, vtNorm))
         return false ;

     // se vicino al bordo del grezzo
      if ( dDist < m_TParams.m_dDiam / 2 + EPS_SMALL) {
         Point3d ptTestO = ptP + vtDirO * ( dDist + m_TParams.m_dDiam / 2 + max( dSafeZ, m_dOpenMinSafe)) ;
         ptTestO += - vtTool * dDepth ;
         double dTestElevO ;
        // se è fuori dal grezzo uso inizio ruotato
         if ( ! GetElevation( m_nPhase, ptTestO, vtTool, m_TParams.m_dDiam / 2, vtTool, dTestElevO)  ||  dTestElevO < EPS_SMALL) {
             Point3d ptNewStart = ptP + vtDirO * ( dDist + m_TParams.m_dDiam / 2 + max( dSafeZ, m_dOpenMinSafe)) ;
             pCompo->AddLine( ptNewStart, ! bLeadIn) ;
             bIsOutsideRaw = true ;
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Pocketing::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 Pocketing : 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 Pocketing : Linear Approx not computable") ;
            return false ;
         }
         VerifyArcs( pRCrv) ;
      }
      else {
         m_pMchMgr->SetLastError( 2413, "Error in Pocketing : 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 Pocketing : Linear Approx not computable") ;
      return false ;
   }
   VerifyArcs( pMCrv) ;

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

//----------------------------------------------------------------------------
bool
Pocketing::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 Pocketing : 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
Pocketing::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) ;
      }
   }
  // altrimenti
   else {
     // se impostato come parametro di lavorazione nelle UserNotes
      Vector3d vtAux ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
         vtAux.Normalize() ;
      SetAuxDir( vtAux) ;
   }
  // 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, MCH_CL_SAFEIN) == 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
Pocketing::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
Pocketing::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
Pocketing::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, MCH_CL_SAFEOUT) == 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, MCH_CL_SAFEOUT) == 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
Pocketing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                            const ICurveComposite* pRCrv, Point3d& ptP1) const
{
  // Assegno tipo e parametri
   int nType = GetLeadInType() ;
   if ( nType == POCKET_LI_GLIDE  &&  ( pRCrv == nullptr  ||  pRCrv->GetCurveCount() == 0))
      nType = POCKET_LI_NONE ;
  // Calcolo punto iniziale
   switch ( nType) {
   case POCKET_LI_NONE :
   case POCKET_LI_ZIGZAG :
   case POCKET_LI_HELIX :
      ptP1 = ptStart ;
      return true ;
   case POCKET_LI_GLIDE :
      {
         double dLen, dU ;
         if ( ! pRCrv->GetLength( dLen)  ||  ! pRCrv->GetParamAtLength( dLen - m_Params.m_dLiTang, dU)  ||
              ! pRCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
            if ( ! pRCrv->GetStartPoint( ptP1))
               return false ;
         }
         ptP1 += vtN * ( vtN * ( ptStart - ptP1)) ;
         return true ;
      }
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Pocketing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                      const ICurveComposite* pCompo, 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( pCompo, 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( pCompo, ptPa, ptPb)) {
         for ( int i = 1 ; i <= nStep ; ++ i) {
            if ( AddLinearMove( ptPa - vtN * ( i - 0.75) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
            if ( AddLinearMove( ptPb - vtN * ( i - 0.25) * dStep, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
         }
         return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
     // altrimenti diretto
      else {
         nType = POCKET_LI_NONE ;
         if ( m_TParams.m_nType == TT_MILL_NOTIP)
            return false ;
      }
   }
  // Se a scivolo e fattibile
   if ( nType == POCKET_LI_GLIDE) {
      if ( pRCrv != nullptr) {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         double dLen, dU ;
         if ( pRCrv->GetLength( dLen)  &&  pRCrv->GetParamAtLength( dLen - m_Params.m_dLiTang, dU)) {
            double dParS, dParE ;
            pRCrv->GetDomain( dParS, dParE) ;
            if ( ! pCrv.Set( ConvertCurveToComposite( pRCrv->CopyParamRange( dU, dParE))))
               return false ;
         }
         else {
            if ( ! pCrv.Set( pRCrv->Clone()))
               return false ;
         }
         pCrv->SetExtrusion( vtN) ;
        // la porto alla giusta quota
         Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
         Vector3d vtMove = ptStart - ptFin ;
         pCrv->Translate( vtMove) ;
        // assegno la corretta pendenza
         double dNini = ( ptP1 - ORIG) * vtN ;
         double dNfin = ( ptStart - ORIG) * vtN ;
         AdjustCurveSlope( pCrv, dNini, dNfin) ;
        // emetto (con eventuale spezzatura)
         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
     // altrimenti diretto
      else
         nType = POCKET_LI_NONE ;
   }
  // Se diretto
   if ( nType == POCKET_LI_NONE) {
      Point3d ptCurr = ptP1 ;
      GetCurrPos( ptCurr) ;
      if ( ! AreSamePointApprox( ptCurr, ptStart)) {
         if ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
            return false ;
      }
      return true ;
   }
  // Altrimenti errore
   return false ;
}

//----------------------------------------------------------------------------
bool
Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
                       Point3d& ptP1, double& dElev)
{
   bool bOppositeHome ;
   return AddLeadOut( ptEnd, vtEnd, vtN, pRCrv, bSplitArcs, bNoneForced, ptP1, dElev, bOppositeHome) ;
}

//----------------------------------------------------------------------------
bool
Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
                       Point3d& ptP1, double& dElev, bool& bOppositeHome)
{
  // 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 ;
        // determino elevazione su fine uscita
         double dEndElev ;
         if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtN, vtN, GetRadiusForStartEndElevation(), vtN, dEndElev))
            dElev = dEndElev ;
        // correzione per punto sotto il grezzo con testa normale da sopra
         double dSafeZ = GetSafeZ() ;
         bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                            GetAhPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(),
                                                m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ;
         bool bUhAboveRaw = ! m_bAboveHead  &&
                              GetUhPointAboveRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(),
                                                  m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ;
         bOppositeHome = ( bAhUnderRaw  ||  bUhAboveRaw) ;
         return true ;
      }
   case POCKET_LO_GLIDE :
      {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         double dU ;
         if ( pRCrv->GetParamAtLength( m_Params.m_dLoTang, dU)) {
            if ( ! pCrv.Set( ConvertCurveToComposite( pRCrv->CopyParamRange( 0, dU))))
               return false ;
         }
         else {
            if ( ! pCrv.Set( pRCrv->Clone()))
               return false ;
         }
        // la porto alla giusta quota
         Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
         Vector3d vtMove = ptEnd - ptIni ;
         pCrv->Translate( vtMove) ;
         Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
        // se lucidatura forzo la stessa quota dell'ingresso
         if ( m_TParams.m_nType == TT_MILL_POLISHING) {
            double dExtraElev = max( m_Params.m_dLiElev, 1.0) ;
            double dNini = ( ptEnd - ORIG) * vtN ;
            double dNfin = dNini + dExtraElev ;
            ptFin += vtN * dExtraElev ;
           // distribuisco l'elevazione extra uniformemente su tutta la curva
            AdjustCurveSlope( pCrv, dNini, dNfin) ;         
         }
         else {            
            ptFin += vtN * 1.0 ;
            pCrv->ModifyEnd( ptFin) ;         
         }
        // emetto (con eventuale spezzatura)
         AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) ;
        // determino elevazione su fine uscita
         ptP1 = ptFin ;
         double dEndElev ;
         if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtN, vtN, GetRadiusForStartEndElevation(), vtN, dEndElev))
            dElev = dEndElev ;
        // correzione per punto sotto il grezzo con testa normale da sopra
         double dSafeZ = GetSafeZ() ;
         bool bAhUnderRaw = m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&
                            GetAhPointUnderRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(),
                                                m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ;
         bool bUhAboveRaw = ! m_bAboveHead  &&
                              GetUhPointAboveRaw( ptP1, vtN, 0, GetRadiusForStartEndElevation(),
                                                  m_TParams.m_dLen, false, dSafeZ, vtN, dElev) ;
         bOppositeHome = ( bAhUnderRaw  ||  bUhAboveRaw) ;
         return true ;
      }
   default :
      bOppositeHome = false ;
      return false ;
   }

}

//----------------------------------------------------------------------------
double
Pocketing::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
Pocketing::GetForcedClosed( void)
{
   int nOpen ;
   return ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, nOpen)  &&  nOpen == 0) ;
}

//----------------------------------------------------------------------------
bool
Pocketing::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
Pocketing::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 Pocketing : 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
Pocketing::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
Pocketing::VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const
{
  // recupero il piano della curva di contorno
   Point3d ptStart ;
   Vector3d vtN ;
   if ( pCompo == nullptr  ||  ! pCompo->GetStartPoint( ptStart)  ||  ! pCompo->GetExtrusion( vtN))
      return false ;
  // porto il centro sullo stesso piano del contorno
   Point3d ptCenL = ptCen - ( ptCen - ptStart) * vtN * vtN ;
  // calcolo la distanza del centro dal contorno
   double dMinDist ;
   return ( DistPointCurve( ptCenL, *pCompo).GetDist( dMinDist)  &&  dMinDist > dRad + 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL) ;
}

//----------------------------------------------------------------------------
bool
Pocketing::VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const
{
  // recupero il piano della curva di contorno
   Point3d ptStart ;
   Vector3d vtN ;
   if ( pCompo == nullptr  ||  ! pCompo->GetStartPoint( ptStart)  ||  ! pCompo->GetExtrusion( vtN))
      return false ;
  // porto i punti sullo stesso piano del contorno
   Point3d ptPaL = ptPa - ( ptPa - ptStart) * vtN * vtN ;
   Point3d ptPbL = ptPb - ( ptPb - ptStart) * vtN * vtN ;
  // calcolo la distanza dei due punti dal contorno
   double dMinDistPa ;
   if ( ! DistPointCurve( ptPaL, *pCompo).GetDist( dMinDistPa))
      return false ;
   double dMinDistPb ;
   if ( ! DistPointCurve( ptPbL, *pCompo).GetDist( dMinDistPb))
      return false ;
   return ( dMinDistPa > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL  &&  dMinDistPb > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL) ;
}

//----------------------------------------------------------------------------
bool
Pocketing::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 ;
}