//----------------------------------------------------------------------------
//  EgalTech 2015-2023
//----------------------------------------------------------------------------
// File : Milling.cpp         Data : 19.12.23          Versione : 2.5l3
// Contenuto : Implementazione gestione fresature.
//
//
//
// Modifiche : 07.06.15 DS Creazione modulo.
//             11.08.16 DS Miglioria gestione PV per più loop.
//             02.06.20 DS Aggiunta gestione Tabs.
//             16.03.22 DS Migliorata sicurezza lame sopra.
//             24.02.22 DS Corretta ed estesa VerifyPathFromBottom.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "Milling.h"
#include "GeoConst.h"
#include "OperationConst.h"
#include "OperUserNotesConst.h"
#include "/EgtDev/Include/EXeCmdLogOff.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkOffsetCurve.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkIntersCurveSurfTm.h"
#include "/EgtDev/Include/EGkIntervals.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtIniFile.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//------------------------------ Constants ------------------------------------
const double OSC_MIN_LEN = 0.1 ;
const double LIM_DOWN_APPRZ = -0.5 ;
const double DELTA_ELEV_RAD = 4.0 ;
const double LIM_SIN_DIFF_DIR = 0.175 ;

//------------------------------ Errors --------------------------------------
// 2301 = "Error in Milling : UpdateToolData failed"
// 2302 = "Error in Milling : Offset not computable"
// 2303 = "Error in Milling : Empty RawBox"
// 2304 = "Error in Milling : Depth not computable"
// 2305 = "Error in Milling : machining depth (xx) bigger than MaxMaterial (yy)"
// 2306 = "Error in Milling : machining step (xx) bigger than MaxMaterial (yy)"
// 2307 = "Error in Milling : missing aggregate from bottom"
// 2308 = "Error in Milling : path too far from part sides"
// 2309 = "Error in Milling : Approach not computable"
// 2310 = "Error in Milling : LeadIn not computable"
// 2311 = "Error in Milling : LeadOut not computable"
// 2312 = "Error in Milling : Retract not computable"
// 2313 = "Error in Milling : Linear Approx not computable"
// 2314 = "Error in Milling : LeadIn must be out of rawpart" 
// 2315 = "Error in Milling : Chaining failed" 
// 2316 = "Error in Milling : Tool MaxMaterial too small (xx)"
// 2317 = "Error in Milling : axes values not calculable"
// 2318 = "Error in Milling : outstroke xx"
// 2319 = "Error in Milling : link movements not calculable"
// 2320 = "Error in Milling : link outstroke xx"
// 2321 = "Error in Milling : post apply not calculable"
// 2322 = "Error in Milling : Tool loading failed"
// 2323 = "Error in Milling : machining depth (xxx) bigger than MaxDepth (yyy)"
// 2324 = "Error in Milling : LeadOut must be out of rawpart"
// 2325 = "Error in Milling : Mirror for Double calculation failed" 
// 2326 = "Error in Milling : special apply not calculable"
// 2351 = "Warning in Milling : Skipped entity (xx)"
// 2352 = "Warning in Milling : No machinable path"
// 2353 = "Warning in Milling : Tool name changed (xx)"
// 2354 = "Warning in Milling : Tool data changed (xx)"
// 2355 = "Warning in Milling : skipped Path too short"
// 2356 = "Warning in Milling : machining step too small (xx)"
// 2357 = "Warning in Milling : machining step (xxx) bigger than MaxMaterial (yyy)"
// 2358 = "Warning in Milling : machining depth (xxx) bigger than MaxMaterial (yyy)"
// 2359 = "Warning in Milling : oscillation incompatible with saw blade"
// 2360 = "Warning in Milling : oscillation incompatible with depth"
// 2361 = "Warning in Milling : oscillation impossible" 
// 2362 = "Warning in Milling : tabs incompatible with saw blade"
// 2363 = "Warning in Milling : tabs impossible"
// 2364 = "Warning in Milling : tabs number less than minimum"

//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_MILLING), Milling) ;

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

//----------------------------------------------------------------------------
Milling*
Milling::Clone( void) const
{
  // alloco oggetto
   Milling* pMill = new( nothrow) Milling ;
  // eseguo copia dei dati
   if ( pMill != nullptr) {
      try {
         pMill->m_vId = m_vId ;
         pMill->m_pMchMgr = m_pMchMgr ;
         pMill->m_nPhase = m_nPhase ;
         pMill->m_Params = m_Params ;
         pMill->m_TParams = m_TParams ;
         pMill->m_dTHoldBase = m_dTHoldBase ;
         pMill->m_dTHoldLen = m_dTHoldLen ;
         pMill->m_dTHoldDiam = m_dTHoldDiam ;
         pMill->m_bTHoldFloating = m_bTHoldFloating ;
         pMill->m_nStatus = m_nStatus ;
         pMill->m_nMills = m_nMills ;
         pMill->m_bStepOn = m_bStepOn ;
         pMill->m_dAddedOverlap = m_dAddedOverlap ;
         pMill->m_nHeadSolCh = m_nHeadSolCh ;
         pMill->m_bTiltingTab = m_bTiltingTab ;
         pMill->m_vtTiltingAx = m_vtTiltingAx ;
         pMill->m_bAboveHead = m_bAboveHead ;
         pMill->m_bAggrBottom = m_bAggrBottom ;
         pMill->m_dCurrOscillLen = m_dCurrOscillLen ;
         pMill->m_dCurrTabsLen = m_dCurrTabsLen ;
         pMill->m_bStartOutRaw = m_bStartOutRaw ;
         pMill->m_bEndOutRaw = m_bEndOutRaw ;
      }
      catch( ...) {
         delete pMill ;
         return nullptr ;
      }
   }
  // ritorno l'oggetto
   return pMill ;
}

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

   return true ;
}

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

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

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Milling::Milling( 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_bTHoldFloating = false ;
   m_nStatus = MCH_ST_TO_VERIFY ;
   m_nMills = 0 ;
   m_bStepOn = false ;
   m_dAddedOverlap = 0 ;
   m_nHeadSolCh = MCH_SCC_NONE ;
   m_bTiltingTab = false ;
   m_bAboveHead = true ;
   m_bAggrBottom = false ;
   m_dCurrOscillLen = 0 ;
   m_dCurrTabsLen = 0 ;
   m_bStartOutRaw = false ;
   m_bEndOutRaw = false ;
}

//----------------------------------------------------------------------------
bool
Milling::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 MillingData* pDdata = GetMillingData( 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
Milling::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_LEAVETAB :
      if ( bVal != m_Params.m_bLeaveTab)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bLeaveTab = 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 ;
   case MPA_OSCENABLE :
      if ( bVal != m_Params.m_bOscEnable)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bOscEnable = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_WORKSIDE :
      if ( ! m_Params.VerifyWorkSide( nVal))
         return false ;
      if ( nVal != m_Params.m_nWorkSide)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nWorkSide = nVal ;
      return true ;
   case MPA_STEPTYPE :
      if ( ! m_Params.VerifyStepType( nVal))
         return false ;
      if ( nVal != m_Params.m_nStepType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nStepType = nVal ;
      return true ;
   case MPA_LEADINTYPE :
      if ( ! m_Params.VerifyLeadInType( nVal))
         return false ;
      if ( nVal != m_Params.m_nLeadInType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nLeadInType = nVal ;
      return true ;
   case MPA_LEADOUTTYPE :
      if ( ! m_Params.VerifyLeadOutType( nVal))
         return false ;
      if ( nVal != m_Params.m_nLeadOutType)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nLeadOutType = nVal ;
      return true ;
   case MPA_TABMIN :
      if ( ! m_Params.VerifyTabMin( nVal))
         return false ;
      if ( nVal != m_Params.m_nTabMin)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nTabMin = nVal ;
      return true ;
   case MPA_TABMAX :
      if ( ! m_Params.VerifyTabMax( nVal))
         return false ;
      if ( nVal != m_Params.m_nTabMax)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_nTabMax = 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_FACEUSE :
      if ( ! m_Params.VerifyFaceUse( nVal))
         return false ;
      if ( nVal != m_Params.m_nFaceUse)
         m_nStatus |= ( MCH_ST_PARAM_MODIF | MCH_ST_GEO_MODIF) ;
      m_Params.m_nFaceUse = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::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_OVERL :
      if ( abs( dVal - m_Params.m_dOverlap) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOverlap = 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_STARTADDLEN :
      if ( abs( dVal - m_Params.m_dStartAddLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartAddLen = dVal ;
      return true ;
   case MPA_ENDADDLEN :
      if ( abs( dVal - m_Params.m_dEndAddLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEndAddLen = dVal ;
      return true ;
   case MPA_OSCHEIGHT :
      if ( abs( dVal - m_Params.m_dOscHeight) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOscHeight = dVal ;
      return true ;
   case MPA_OSCRAMPLEN :
      if ( abs( dVal - m_Params.m_dOscRampLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOscRampLen = dVal ;
      return true ;
   case MPA_OSCFLATLEN :
      if ( abs( dVal - m_Params.m_dOscFlatLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOscFlatLen = dVal ;
      return true ;
   case MPA_TABLEN :
      if ( abs( dVal - m_Params.m_dTabLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTabLen = dVal ;
      return true ;
   case MPA_TABDIST :
      if ( abs( dVal - m_Params.m_dTabDist) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTabDist = dVal ;
      return true ;
   case MPA_TABHEIGHT :
      if ( abs( dVal - m_Params.m_dTabHeight) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTabHeight = dVal ;
      return true ;
   case MPA_TABANGLE :
      if ( abs( dVal - m_Params.m_dTabAngle) > EPS_MACH_ANG_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTabAngle = dVal ;
      return true ;
   case MPA_LITANG :
      if ( abs( dVal - m_Params.m_dLiTang) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiTang = dVal ;
      return true ;
   case MPA_LIPERP :
      if ( abs( dVal - m_Params.m_dLiPerp) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiPerp = dVal ;
      return true ;
   case MPA_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_LICOMPLEN :
      if ( abs( dVal - m_Params.m_dLiCompLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLiCompLen = dVal ;
      return true ;
   case MPA_LOTANG :
      if ( abs( dVal - m_Params.m_dLoTang) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoTang = dVal ;
      return true ;
   case MPA_LOPERP :
      if ( abs( dVal - m_Params.m_dLoPerp) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoPerp = dVal ;
      return true ;
   case MPA_LOELEV :
      if ( abs( dVal - m_Params.m_dLoElev) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoElev = dVal ;
      return true ;
   case MPA_LOCOMPLEN :
      if ( abs( dVal - m_Params.m_dLoCompLen) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dLoCompLen = dVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::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 ;
         Vector3d vtNew ; GetValInNotes( sVal, UN_VTFACEUSE, vtNew) ;
         Vector3d vtOri ; GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtOri) ;
         if ( ! AreSameVectorApprox( vtNew, vtOri))
            m_nStatus |= MCH_ST_GEO_MODIF ;
         INTVECTOR vnNew ; GetValInNotes( sVal, UN_EDGESFACEUSE, vnNew) ;
         INTVECTOR vnOri ; GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnOri) ;
         if ( vnNew != vnOri)
            m_nStatus |= MCH_ST_GEO_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
Milling::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, tutti testi 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 Milling : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2351, 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
Milling::Preview( bool bRecalc)
{
  // reset numero percorsi di lavoro generati
   m_nMills = 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( 2301, "Error in Milling : UpdateToolData failed") ;
      return false ;
   }
   m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;

  // aggiorno anche se non necessario, comunque operazione veloce

  // 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( 2322, "Error in Milling : 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) ;
   m_bTHoldFloating = m_pMchMgr->GetCurrMachine()->IsCurrToolFloating() ;

  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
   if ( bChain  &&  ! Chain( nAuxId)) {
      m_pMchMgr->SetLastError( 2315, "Error in Milling : 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
Milling::Apply( bool bRecalc, bool bPostApply)
{
  // reset numero percorsi di lavoro generati
   int nCurrMills = m_nMills ;
   m_nMills = 0 ;

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

  // aggiorno dati geometrici dell'utensile
   if ( ! UpdateToolData()) {
      m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ;
      return false ;
   }
   m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;

  // 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_nMills = nCurrMills ;
      string sLog = string( "Milling 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 ;
   }

  // recupero gruppo per vista ausiliaria
   int nAuxViewId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
  // se non c'è, lo aggiungo
   if ( nAuxViewId == GDB_ID_NULL) {
      nAuxViewId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nAuxViewId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nAuxViewId, MCH_AUXVIEW) ;
      m_pGeomDB->SetMaterial( nAuxViewId, Color( 64, 0, 0)) ;
      m_pGeomDB->SetStatus( nAuxViewId, GDB_ST_OFF) ;
   }
  // altrimenti, se necessario chain, lo svuoto
   else if ( bChain) {
      m_pGeomDB->EmptyGroup( nAuxViewId) ;
   }

  // 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( 2322, "Error in Milling : 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) ;
   m_bTHoldFloating = m_pMchMgr->GetCurrMachine()->IsCurrToolFloating() ;

  // 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) {
      if ( ! Chain( nAuxId)) {
         m_pMchMgr->SetLastError( 2315, "Error in Milling : Chaining failed") ;
         return false ;
      }
      CalcSurfAuxView( nAuxId, nAuxViewId) ;
   }

  // 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( 2325, "Error in Milling : 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(), "Milling apply done") ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::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_nMills == 0) {
      m_pMchMgr->SetWarning( 2352, "Warning in Milling : No machinable path") ;
      return true ;
   }

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

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

  // calcolo gli assi macchina
   string sHint = ExtractHint( m_Params.m_sUserNotes) ;
   if ( ! m_Params.m_sInitAngs.empty())
      sHint = m_Params.m_sInitAngs ;
   if ( ! CalculateAxesValues( sHint)) {
      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
      if ( sInfo.empty())
         m_pMchMgr->SetLastError( 2317, "Error in Milling : axes values not calculable") ;
      else
         m_pMchMgr->SetLastError( 2318, "Error in Milling : 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 sTcPos; string sDblHead ; int nDblExit ;
      bool bOk = GetDoubleToolData( sDblTool, sTcPos, 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( 2317, "Error in Milling : axes values not calculable for double") ;
            else
               m_pMchMgr->SetLastError( 2318, "Error in Milling : 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( 2326, sSpecErr) ;
      else
         m_pMchMgr->SetLastError( 2326, "Error in Milling : special apply not calculable") ;
      return false ;
   }

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

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

   return true ;
}

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

//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_MILLING ;
      return true ;
   case MPA_WORKSIDE :
      nVal = m_Params.m_nWorkSide ;
      return true ;
   case MPA_STEPTYPE :
      nVal = m_Params.m_nStepType ;
      return true ;
   case MPA_LEADINTYPE :
      nVal = m_Params.m_nLeadInType ;
      return true ;
   case MPA_LEADOUTTYPE :
      nVal = m_Params.m_nLeadOutType ;
      return true ;
   case MPA_TABMIN :
      nVal = m_Params.m_nTabMin ;
      return true ;
   case MPA_TABMAX :
      nVal = m_Params.m_nTabMax ;
      return true ;
   case MPA_SCC :
      nVal = m_Params.m_nSolCh ;
      return true ;
   case MPA_FACEUSE :
      nVal = m_Params.m_nFaceUse ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::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_OVERL :
      dVal = m_Params.m_dOverlap ;
      return true ;
   case MPA_STEP :
      dVal = m_Params.m_dStep ;
      return true ;
   case MPA_STARTADDLEN :
      dVal = m_Params.m_dStartAddLen ;
      return true ;
   case MPA_ENDADDLEN :
      dVal = m_Params.m_dEndAddLen ;
      return true ;
   case MPA_OSCHEIGHT :
      dVal = m_Params.m_dOscHeight ;
      return true ;
   case MPA_OSCRAMPLEN :
      dVal = m_Params.m_dOscRampLen ;
      return true ;
   case MPA_OSCFLATLEN :
      dVal = m_Params.m_dOscFlatLen ;
      return true ;
   case MPA_TABLEN :
      dVal = m_Params.m_dTabLen ;
      return true ;
   case MPA_TABDIST :
      dVal = m_Params.m_dTabDist ;
      return true ;
   case MPA_TABHEIGHT :
      dVal = m_Params.m_dTabHeight ;
      return true ;
   case MPA_TABANGLE :
      dVal = m_Params.m_dTabAngle ;
      return true ;
   case MPA_LITANG :
      dVal = m_Params.m_dLiTang ;
      return true ;
   case MPA_LIPERP :
      dVal = m_Params.m_dLiPerp ;
      return true ;
   case MPA_LIELEV :
      dVal = m_Params.m_dLiElev ;
      return true ;
   case MPA_LICOMPLEN :
      dVal = m_Params.m_dLiCompLen ;
      return true ;
   case MPA_LOTANG :
      dVal = m_Params.m_dLoTang ;
      return true ;
   case MPA_LOPERP :
      dVal = m_Params.m_dLoPerp ;
      return true ;
   case MPA_LOELEV :
      dVal = m_Params.m_dLoElev ;
      return true ;
   case MPA_LOCOMPLEN :
      dVal = m_Params.m_dLoCompLen ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

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

//----------------------------------------------------------------------------
bool
Milling::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 Milling : tool name changed (" +
                     m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
      m_pMchMgr->SetWarning( 2353, sInfo) ;
      m_Params.m_sToolName = m_TParams.m_sName ;
   }
   if ( bChanged) {
      string sInfo = "Warning in Milling : tool data changed (" +
                      m_Params.m_sToolName + ")" ;
      m_pMchMgr->SetWarning( 2354, sInfo) ;
   }
  // se modificato, aggiusto lo stato
   if ( bChanged)
      m_nStatus = MCH_ST_TO_VERIFY ;
   return true ;
}

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

//----------------------------------------------------------------------------
bool
Milling::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 ;
     // tutto bene
      nSubs = 0 ;
      return true ;
   }
  // se altrimenti ammesse superfici trimesh ed è tale
   else if ( ( nType == GEO_NONE  ||  nType == GEO_SURF)  &&  pGObj->GetType() == SRF_TRIMESH) {
      nType = GEO_SURF ;
      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 == GEO_SURF)  &&  pGObj->GetType() == SRF_FLATRGN) {
      nType = GEO_SURF ;
      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
Milling::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()) ;
         if ( IsNull( pCurve))
            return false ;
        // 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()) ;
         if ( IsNull( pCurve))
            return false ;
        // 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) ;
      }
     // 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 ;
     // porto le curve in globale
      for ( auto pCrv : lstPC)
         pCrv->ToGlob( frGlob) ;
     // ritorno
      return true ;  
   }
  // se altrimenti superficie trimesh
   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 ;
     // 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
      int nToolDir ;
      if ( ( m_Params.m_nFaceUse & 64) != 0)
         nToolDir = TOOL_ORTUP ;
      else if ( ( m_Params.m_nFaceUse & 32) != 0)
         nToolDir = TOOL_ORTHO ;
      else
         nToolDir = TOOL_PARAL ;
      int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
      Vector3d vtFaceUse ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse)  &&  ! vtFaceUse.IsSmall())
         nFaceUse = FACE_VERSOR ;
      INTVECTOR vnEdgesFaceUse ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse)  &&  ! vnEdgesFaceUse.empty())
         nFaceUse = FACE_EDGES ;
      double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
      if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
         return false ;
     // 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 ;
     // sistemazioni varie
      int nToolDir ;
      if ( ( m_Params.m_nFaceUse & 64) != 0)
         nToolDir = TOOL_ORTUP ;
      else if ( ( m_Params.m_nFaceUse & 32) != 0)
         nToolDir = TOOL_ORTHO ;
      else
         nToolDir = TOOL_PARAL ;
      int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
      Vector3d vtFaceUse ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse)  &&  ! vtFaceUse.IsSmall())
         nFaceUse = FACE_VERSOR ;
      INTVECTOR vnEdgesFaceUse ;
      if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse)  &&  ! vnEdgesFaceUse.empty())
         nFaceUse = FACE_EDGES ;
      double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
     // determino intervallo di chunk
      int nCstart = 0 ;
      int nCend = pReg->GetChunkCount() ;
      if ( Id.nSub != SEL_SUB_ALL) {
         nCstart = Id.nSub ;
         nCend = nCstart + 1 ;
      }
      else if ( nFaceUse == FACE_EDGES) {
         nCstart = 0 ;
         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 ;
           // 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
            if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
               return false ;
           // la restituisco
            lstPC.emplace_back( Release( pCrvCompo)) ;
         }
      }
      return true ;
   }
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
Milling::Chain( int nGrpDestId)
{
  // vettore puntatori alle curve
   ICURVEPOVECTOR vpCrvs ;
   vpCrvs.reserve( m_vId.size()) ;
  // vettore selettori delle curve originali
   SELVECTOR vInds ;
   vInds.reserve( m_vId.size()) ;
  // 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 Milling : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2351, 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))
         return false ;
     // 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 ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const
{
  // se utensile lama
   if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
     // traslazione opposta a quanto fatto in AdjustPathDrawForSaw
      double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
      ptP.Translate( dOffset * pCamData->GetCorrDir()) ;
   }
  // negli altri casi, non devo fare alcunché
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AdjustArcCenterForAxesCalc( const CamData* pCamData, Point3d& ptCen) const
{
  // se utensile lama
   if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
     // recupero il precedente movimento
      int nPrevId = m_pGeomDB->GetPrev( pCamData->GetOwner()) ;
      CamData* pPrevCamData = GetCamData( m_pGeomDB->GetUserObj( nPrevId)) ;
      if ( pPrevCamData == nullptr)
         return false ;
     // se versori correzione uguali, correggo il centro
      if ( AreSameVectorApprox( pCamData->GetCorrDir(), pPrevCamData->GetCorrDir())) {
        // traslazione opposta a quanto fatto in AdjustPathDrawForSaw
         double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
         ptCen.Translate( dOffset * pCamData->GetCorrDir()) ;
      }
   }
  // negli altri casi, non devo fare alcunché
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcSurfAuxView( int nAuxId, int nAuxViewId)
{
   const double FAT_RAD = 0.5 ;
   if ( m_Params.m_nFaceUse != MILL_FU_NONE) {
      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
      while ( nPathId != GDB_ID_NULL) {
         int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
         const ICurve* pCrv = ::GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
         if ( pCrv != nullptr) {
            ISurfFlatRegion* pSfr = GetSurfFlatRegionFromFatCurve( pCrv->Clone(), FAT_RAD, false, false) ;
            if ( pSfr != nullptr) {
               int nSfrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nAuxViewId, pSfr) ;
            }
         }
         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::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) ;

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

  // converto in archi e rette
   pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;

  // eventuale inversione percorso
   if ( m_Params.m_bInvert)
      pCompo->Invert() ;

  // recupero direzione utensile da estrusione e spessore
   Vector3d vtTool ;
   pCompo->GetExtrusion( vtTool) ;
   if ( vtTool.IsSmall())
      vtTool = Z_AX ;
   double dThick ;
   pCompo->GetThickness( dThick) ;

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

  // se percorso chiuso con inizio/fine su angolo interno, porto la partenza a metà del primo lato
   if ( pCompo->IsClosed()) {
      Vector3d vtStart, vtEnd ;
      pCompo->GetStartDir( vtStart) ;
      pCompo->GetEndDir( vtEnd) ;
      if ( ! AreSameOrOppositeVectorApprox( vtStart, vtEnd)) {
         bool bAngCCW = ( ( vtEnd ^ vtStart) * vtTool > 0.0) ;
         if ( m_Params.m_dOverlap > EPS_SMALL  ||
              m_Params.m_nWorkSide == MILL_WS_CENTER  ||
              ( m_Params.m_nWorkSide == MILL_WS_RIGHT  &&  ! bAngCCW)  ||
              ( m_Params.m_nWorkSide == MILL_WS_LEFT  &&  bAngCCW))
            pCompo->ChangeStartPoint( 0.5) ;
      }
   }

  // eventuali allungamenti/accorciamenti per percorso aperto o chiuso senza sovrapposizione
   if ( ! pCompo->IsClosed()  ||  m_Params.m_dOverlap < EPS_SMALL) {
     // verifico che il percorso sia abbastanza lungo
      double dLen ; pCompo->GetLength( dLen) ;
      if ( dLen + m_Params.m_dStartAddLen + m_Params.m_dEndAddLen < 10 * EPS_SMALL) {
         m_pMchMgr->SetWarning( 2355,  "Warning in Milling : skipped Path too short") ;
         return true ;
      }
     // se una sola entità circonferenza completa, la divido in due per poterla allungare
      if ( pCompo->GetCurveCount() == 1  &&  pCompo->IsClosed())
         pCompo->AddJoint( 0.5) ;
     // eventuali allungamenti
      if ( m_Params.m_dStartAddLen > EPS_SMALL) {
         if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen))
            return false ;
         dLen += m_Params.m_dStartAddLen ;
      }
      if ( m_Params.m_dEndAddLen > EPS_SMALL) {
         if ( ! pCompo->ExtendEndByLen( m_Params.m_dEndAddLen))
            return false ;
         dLen += m_Params.m_dEndAddLen ;
      }
     // eventuale accorciamenti (da fare dopo tutti gli allungamenti)
      if ( m_Params.m_dStartAddLen < - EPS_SMALL) {
         if ( ! pCompo->TrimStartAtLen( - m_Params.m_dStartAddLen))
            return false ;
         dLen += m_Params.m_dStartAddLen ;
      }
      if ( m_Params.m_dEndAddLen < - EPS_SMALL) {
         if ( ! pCompo->TrimEndAtLen( dLen + m_Params.m_dEndAddLen))
            return false ;
         dLen += m_Params.m_dEndAddLen ;
      }
   }

  // eventuale spostamento inizio per percorso chiuso con sovrapposizione
   if ( pCompo->IsClosed()  &&  m_Params.m_dOverlap > EPS_SMALL  &&  abs( m_Params.m_dStartAddLen) > EPS_SMALL) {
      double dPos = -m_Params.m_dStartAddLen ;
      if ( dPos < 0) {
         double dLen ;
         pCompo->GetLength( dLen) ;
         dPos += dLen ;
      }
      double dPar ;
      if ( pCompo->GetParamAtLength( dPos, dPar))
         pCompo->ChangeStartPoint( dPar) ;
   }

  // salvo direzioni iniziale e finale del percorso prima di eventuale offset
   pCompo->GetStartDir( m_vtStartDir) ;
   pCompo->GetEndDir( m_vtEndDir) ;
  // se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset
   double dOffs = 0.5 * m_TParams.m_dDiam + GetOffsR() ;
   if ( m_Params.m_nWorkSide != MILL_WS_CENTER  &&  abs( dOffs) > EPS_SMALL) {
     // valore offset 
      double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ;
     // esecuzione offset
      if ( ! CalcOffset( pCompo, dSignOffs)) {
         m_pMchMgr->SetLastError( 2302, "Error in Milling : Offset not computable") ;
         return false ;
      }
   }

  // eventuale sovrapposizione per percorso chiuso
   m_dAddedOverlap = 0 ;
   if ( pCompo->IsClosed()  &&  m_Params.m_dOverlap > EPS_SMALL) {
      double dParS, dParE ;
      if ( pCompo->GetParamAtLength( 0.0, dParS)  &&
           pCompo->GetParamAtLength( m_Params.m_dOverlap, dParE)) {
         PtrOwner<ICurve> pCrv( pCompo->CopyParamRange( dParS, dParE)) ;
         if ( ! IsNull( pCrv)) {
            pCompo->AddCurve( Release( pCrv)) ;
            m_dAddedOverlap = m_Params.m_dOverlap ;
         }
      }
   }

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

  // flags per tabs e oscillazione del percorso corrente (se entrambi, solo tabs)
   bool bPathTabsEnable = m_Params.m_bLeaveTab ;
   bool bPathOscEnable = ( ! bPathTabsEnable  &&  m_Params.m_bOscEnable) ;

  // se utensile lama, disabilito eventuali tabs o oscillazione
   if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
      if ( bPathTabsEnable) {
         bPathTabsEnable = false ;
         m_pMchMgr->SetWarning( 2362, "Warning in Milling : tabs incompatible with saw blade") ;
      }
      if ( bPathOscEnable) {
         bPathOscEnable = false ;
         m_pMchMgr->SetWarning( 2359, "Warning in Milling : oscillation incompatible with saw blade") ;
      }
   }

  // recupero i punti di inizio e fine (per poi salvarli nelle info di CL path)
   Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
   Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;

  // 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( 2303, "Error in Milling : Empty RawBox") ;
      return false ;
   }

  // recupero distanza da fondo dei grezzi interessati dal percorso
   double dRbDist = 0 ;
   if ( AreSameVectorApprox( vtTool, 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( 2304, "Error in Milling : 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) ;

  // eventuale approssimazione con segmenti di retta
   bool bSplitArcs = GetSplitArcs( vtTool) ;
   if ( bSplitArcs) {
      if ( ! ApproxWithLines( pCompo)) {
         m_pMchMgr->SetLastError( 2313, "Error in Milling : Linear Approx not computable") ;
         return false ;
      }
   }

  // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
   VerifyArcs( pCompo) ;

  // calcolo l'elevazione massima
   double dElev ;
   if ( CalcPathElevation( pCompo, vtTool, dDepth, 0.5 * m_TParams.m_dDiam, dElev)) {
      if ( dElev < EPS_SMALL  &&  AreSameVectorApprox( vtTool, 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 ;
  // eventuale aggiuntivo all'elevazione per l'oscillazione
   double dAddElev = ( bPathOscEnable ? abs( m_Params.m_dOscHeight) : 0) ;
  // eventuale elevazione di fianco (solo per lama)
   double dSideElev = 0 ;
   GetValInNotes( m_Params.m_sUserNotes, UN_SIDEELEV, dSideElev) ;

  // verifico che lo step dell'utensile sia sensato
   double dOkStep = 0 ;
   bool bStepUp = false ;
   if ( m_bTHoldFloating)
      dOkStep = 0 ;
   else if ( m_Params.m_dStep > EPS_SMALL)
      dOkStep = m_Params.m_dStep + EPS_ZERO ;
   else if ( m_Params.m_dStep < -EPS_SMALL  &&
             ( m_TParams.m_nType == TT_MILL_NOTIP  ||
               ( ( m_TParams.m_nType & TF_SAWBLADE) != 0  &&  abs( dSideElev) < 10 * EPS_SMALL))) {
      dOkStep = abs( m_Params.m_dStep) + EPS_ZERO ;
      bStepUp = true ;
   }
   const double MIN_ZSTEP = ( m_TParams.m_nType != TT_MILL_POLISHING ? 0.1 : EPS_SMALL) ;
   if ( dOkStep >= EPS_SMALL  &&  dOkStep < MIN_ZSTEP) {
      dOkStep = MIN_ZSTEP + EPS_ZERO ;
      string sInfo = "Warning in Milling : machining step too small (" +
                     ToString( m_Params.m_dStep, 2) + ")" ;
      m_pMchMgr->SetWarning( 2356, 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 Milling : Tool MaxMaterial too small (" +
                     ToString( m_TParams.m_dMaxMat, 2) + ")" ;
      m_pMchMgr->SetLastError( 2316, sInfo) ;
      return false ;
   }

  // per frese normali, verifico di non superare il massimo materiale con possibilità di aggiustare
   if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
     // 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 Milling : machining step (" + ToString( m_Params.m_dStep, 1) +
                        ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
         m_pMchMgr->SetWarning( 2357, sInfo) ;
      }
     // se lavorazione singola
      if ( dOkStep < EPS_SMALL  ||  dOkStep > dElev + dAddElev) {
        // se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione
         if ( bPathOscEnable  &&  dElev + dAddElev > m_TParams.m_dMaxMat + EPS_SMALL) {
            bPathOscEnable = false ;
            dAddElev = 0 ;
            m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ;
         }
        // se l'elevazione supera la capacità dell'utensile
         if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
           // segnalo, riduco e continuo
            string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
                           ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
            m_pMchMgr->SetWarning( 2358, sInfo) ;
            dDepth -= dElev - m_TParams.m_dMaxMat ;
            dElev = m_TParams.m_dMaxMat ;
         }
      }
     // altrimenti lavorazione a step
      else {
        // massimo affondamento dell'utensile
         double dSafe = GetMaxDepthSafe() ;
         double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
        // se c'è oscillazione e l'elevazione complessiva supera la capacità dell'utensile, annullo l'oscillazione
         if ( bPathOscEnable  &&  dElev + dAddElev > dMaxDepth + EPS_SMALL) {
            bPathOscEnable = false ;
            dAddElev = 0 ;
            m_pMchMgr->SetWarning( 2360, "Warning in Milling : oscillation incompatible with depth") ;
         }
        // se l'elevazione supera il massimo affondamento dell'utensile
         if ( dElev > dMaxDepth + EPS_SMALL) {
           // segnalo, riduco e continuo
            string sInfo = "Warning in Milling : machining depth (" + ToString( dElev, 1) +
                           ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
            m_pMchMgr->SetWarning( 2358, sInfo) ;
            dDepth -= dElev - dMaxDepth ;
            dElev = dMaxDepth ;
         }  
      }
   }
  // per lame e con elevazione di lato definita
   else if ( abs( dSideElev) > EPS_SMALL) {
     // caso standard
      if ( dSideElev > 0) {
        // se l'elevazione di lato supera la capacità dell'utensile
         if ( dSideElev > m_TParams.m_dMaxMat + EPS_SMALL) {
            string sInfo = "Error in Milling : machining depth (" + ToString( dSideElev, 1) +
                           ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
            m_pMchMgr->SetLastError( 2305, sInfo) ;
            return false ;
         }
      }
     // per tagli a cubetti (ciascuno step di taglio cade)
      else {
        // se lo step supera la capacità dell'utensile
         if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
            string sInfo = "Error in Milling : machining step (" + ToString( m_Params.m_dStep, 1) +
                           ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
            m_pMchMgr->SetLastError( 2306, sInfo) ;
            return false ;
         }
         dSideElev = abs( dSideElev) ;
      }
   }

  // 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 fresatura dal basso
   m_bAggrBottom = false ;
   if ( ! VerifyPathFromBottom( pCompo, vtTool))
      return false ;

  // recupero eventuale flag di inizio forzato fuori dal grezzo
   int nStartOutRaw = 0 ;
   GetValInNotes( m_Params.m_sUserNotes, UN_OUTRAW, nStartOutRaw) ;
   m_bStartOutRaw = (( nStartOutRaw & 1) != 0) ;
   m_bEndOutRaw = (( nStartOutRaw & 2) != 0) ;

  // se richiesta anteprima
   if ( nPvId != GDB_ID_NULL) {
     // creo gruppo per geometria di anteprima 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) ;

     // 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, ptEnd) ;
     // assegno l'elevazione massima
      m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;

     // creo l'anteprima del percorso
      if ( ! GenerateMillingPv( nPxId, pCompo, dRbDist, dDepth))
         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) ;

     // 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, ptEnd) ;
     // assegno l'elevazione massima
      m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;

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

     // Controlli per lama (non deve fare movimenti assiali nel pezzo)
      if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
        // Non ammesse passate a spirale
         if ( m_Params.m_nStepType == MILL_ST_SPIRAL)
            m_Params.m_nStepType = MILL_ST_ZIGZAG ;
        // Non ammessa elevazione in attacco e uscita
         m_Params.m_dLiElev = 0 ;
         m_Params.m_dLoElev = 0 ;
      }

     // Controlli per fresa che non lavora di punta (non deve fare movimenti assiali nel pezzo)
      if ( m_TParams.m_nType == TT_MILL_NOTIP) {
        // Non ammesse passate a spirale
         if ( m_Params.m_nStepType == MILL_ST_SPIRAL)
            m_Params.m_nStepType = MILL_ST_ZIGZAG ;
        // Ammessa elevazione in attacco e uscita
      }

      bool bOk = false ;

     // Se lama con elevazione e step di fianco
      if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0  &&  dSideElev > 10 * EPS_SMALL  &&  dOkStep > EPS_SMALL) {
         m_bStepOn = true ;
         if ( m_Params.m_nStepType != MILL_ST_ONEWAY)
            bOk = AddSawZigZagMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs) ;
         else
            bOk = AddSawOneWayMilling( pCompo, vtTool, dDepth, dSideElev, dOkStep, bSplitArcs) ;
      }
     // se altrimenti una sola passata
      else if ( dOkStep < EPS_SMALL  ||  dOkStep > dElev) {
         m_bStepOn = false ;
         bOk = AddStandardMilling( pCompo, vtTool, dDepth, dElev, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
      }
     // se altrimenti passate a zig-zag
      else if ( m_Params.m_nStepType == MILL_ST_ZIGZAG) {
         m_bStepOn = true ;
         bOk = AddZigZagMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bStepUp, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
      }
     // se altrimenti passate a one-way
      else if ( m_Params.m_nStepType == MILL_ST_ONEWAY) {
         m_bStepOn = true ;
         bOk = AddOneWayMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bStepUp, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
      }
     // se altrimenti passate a spirale
      else if ( m_Params.m_nStepType == MILL_ST_SPIRAL) {
         m_bStepOn = true ;
        // rimuovo eventuale sovrapposizione aggiunta
         if ( m_dAddedOverlap > EPS_SMALL) {
            pCompo->Invert() ;
            pCompo->TrimStartAtLen( m_dAddedOverlap) ;
            pCompo->Invert() ;
            m_dAddedOverlap = 0 ;
         }
         bOk = AddSpiralMilling( pCompo, vtTool, dDepth, dElev, dOkStep, bSplitArcs, bPathTabsEnable, bPathOscEnable) ;
      }

     // se utensile lama, porto il percorso sull'estremo della stessa
      AdjustPathDrawForSaw( nPxId) ;

      if ( ! bOk)
         return false ;
   }

  // incremento numero di fresate
   ++ m_nMills ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AdjustPathDrawForSaw( int nClPathId)
{
  // se non è lama, non devo fare alcunché
   if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0)
      return true ;
  // porto il percorso praticamente sull'estremo della lama ( appena meno per evitare di trasformare archi in punti)
   double dOffset = 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
   Vector3d vtPrevCorr ;
   for ( int nId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
         nId != GDB_ID_NULL ;
         nId = m_pGeomDB->GetNext( nId)) {
     // recupero l'oggetto geometrico
      IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nId) ;
      if ( pGObj == nullptr)
         continue ;
     // recupero i dati Cam dell'entità e verifico sia definito il versore correzione
      CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nId)) ;
      if ( pCamData == nullptr  ||  pCamData->GetCorrDir().IsSmall())
         continue ;
      Vector3d vtCorr = pCamData->GetCorrDir() ;
     // eseguo traslazione generale
      Vector3d vtMove = - dOffset * vtCorr ;
      pGObj->Translate( vtMove) ;
      pCamData->Translate( vtMove) ;
     // se il vettore correzione attuale è diverso dal precedente
      if ( ! AreSameVectorApprox( vtCorr, vtPrevCorr)) {
        // se curva
         if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
           // compenso differenza su punto iniziale
            Vector3d vtDiff = - dOffset * ( vtPrevCorr - vtCorr) ;
            ICurve* pCrv = ::GetCurve( pGObj) ;
            Point3d ptStart ;
            pCrv->GetStartPoint( ptStart) ;
            pCrv->ModifyStart( ptStart + vtDiff) ;
           // se arco, aggiorno il centro
            if ( pGObj->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCrv) ;
               pCamData->SetCenter( pArc->GetCenter()) ;
            }
         }
      }
     // aggiorno precedente versore correzione
      vtPrevCorr = vtCorr ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
                            double& dElev) const
{
  // default
   dElev = 0 ;
  // controllo il raggio utensile
   double const MIN_RAD = 5 ; 
   dRad = max( dRad, MIN_RAD) ;
  // approssimo la curva con una polilinea
   PolyLine PL ;
   if ( ! pCompo->ApproxWithLines( LIN_TOL_RAW, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
      return false ;
   double const MIN_STEP = 5 ;
   double const MAX_STEP = 500 ;
   double dStep = Clamp( dRad, MIN_STEP, MAX_STEP) ;
   PL.AdjustForMaxSegmentLen( dStep) ;
  // calcolo l'elevazione
   Point3d ptP ;
   bool bFound = PL.GetFirstPoint( ptP) ;
   while ( bFound) {
      double dPtElev ;
      if ( ! GetElevation( m_nPhase, ptP - vtTool * dDepth, vtTool, dRad, vtTool, dPtElev))
         return false ;
      dElev = max( dElev, dPtElev) ;
      bFound = PL.GetNextPoint( ptP) ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
{
  // se non è fresatura 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( 2307, "Error in Milling : missing aggregate from bottom") ;
      return false ;
   }

  // calcolo il minimo della massima distanza del percorso dal contorno del grezzo
   double dExpand = 0.5 * m_TParams.m_dTDiam ;
   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, dExpand, 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 + dExpand > dCurrDist)
                     dCurrDist = dQDist + dExpand ;     
               }
            }
           // 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_AggrBottom.dDMax) {
      m_pMchMgr->SetLastError( 2308, "Error in Milling : 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
Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo, double dRbDist, double dDepth)
{
  // creo copia della curva composita
   PtrOwner< ICurve> pCrv( pCompo->Clone()) ;
   if ( IsNull( pCrv))
      return false ;
  // calcolo la regione
   PtrOwner<ISurfFlatRegion> pSfr ;
   pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), 0.5 * m_TParams.m_dDiam, false, false)) ;
   if ( IsNull( pSfr))
      return false ;
  // ne recupero i contorni
   for ( int i = 0 ; i < pSfr->GetLoopCount( 0) ; i++) {
      PtrOwner<ICurve> pCrv2( pSfr->GetLoop( 0, i)) ;
      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, LIME) ; 
   }

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

  // creo regioni di lavorazione che interessano le superfici superiore e inferiore del grezzo
  // casi inclinati da gestire !
   int nUpId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
   m_pGeomDB->SetName( nUpId, MCH_PV_UP_RAWCUT) ;
   if ( dRbDist > EPS_SMALL  &&  dRbDist - dDepth < EPS_SMALL) {      
      int nDwnId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
      m_pGeomDB->SetName( nDwnId, MCH_PV_DOWN_RAWCUT) ;  
   } 

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                             double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // extra lunghezza utensile
   double dExtraLen = max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
   double dExtrAppr = dAppr + dExtraLen ;
  // delta da punto lavoro a punto tip
   Vector3d vtWkTip = -vtTool * dExtraLen ; 

  // Recupero flag per rapidi su inizio/fine se fuori
   string sMachIni = m_pMchMgr->GetCurrMachine()->GetMachineDir() + "\\" + m_pMchMgr->GetCurrMachine()->GetMachineName() + ".ini" ;
   bool bRapidOnOut = ( GetPrivateProfileInt( MACHININGS_SEC.c_str(), RAPIDONOUT_KEY.c_str(), 0, sMachIni.c_str()) == 1) ;

  // Recupero necessità indicizzazione per variazioni di lavorazione ("MVar" da porte)
   bool bIndex = false ;
   string sInfo ;
   if ( m_Params.m_nWorkSide == MILL_WS_CENTER  &&  m_vId.size() == 1  &&  m_pGeomDB->GetInfo( m_vId[0].nId, "MVar", sInfo))
      bIndex = true ;

  // in caso di tabs ne aggiusto i parametri secondo il percorso
   TabData tdTabs ;
   AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
   DBLVECTOR vdTabs ;
   CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;

  // in caso di oscillazione ne aggiusto i parametri secondo il percorso
   double dOscRampLen, dOscFlatLen ;
   AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;

  // ciclo sulle curve elementari
   bool bOk = true ;
   m_dCurrTabsLen = 0 ;
   m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
   int nMaxInd = pCompo->GetCurveCount() - 1 ;
   for ( int i = 0 ; i <= nMaxInd ; ++ i) {
     // curva corrente
      const ICurve* pCrvC = pCompo->GetCurve( i) ;
     // copio la curva
      PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
      if ( IsNull( pCurve))
         return false ;
     // aggiungo affondamento
      pCurve->Translate( - vtTool * dDepth) ;
     // se prima entità, approccio e affondo
      if ( i == 0) {
        // reset index
         SetIndex( 0) ;
        // dati inizio entità
         Point3d ptStart ;
         pCurve->GetStartPoint( ptStart) ;
         Vector3d vtStart = m_vtStartDir ;
        // determino elevazione su inizio percorso di lavoro
         double dStElev ;
         if ( GetElevation( m_nPhase, ptStart + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
            dStElev = max( dStElev - dExtraLen, 0.) ;
         else
            dStElev = dElev ;
        // determino inizio attacco
         Point3d ptP1 ;
         Vector3d vtDir1 ;
         double dCalcStElev = dStElev ;
         if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
            return false ;
        // determino se l'inizio dell'attacco è fuori dal grezzo
         Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
         if ( ! vtAppr.Normalize())
            vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
         bool bOutStart = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtAppr, dSafeZ) ;
        // determino se l'inizio dell'attacco è sopra il grezzo
         bool bGeomAboveStart = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
         bool bAboveStart = false ;
         if ( m_bAboveHead) {
            if ( ! m_bTiltingTab)
               bAboveStart = bGeomAboveStart ;
            else {
               if ( bOutStart)
                  dStElev = min( dStElev, dElev) ;
            }
         }
        // imposto versore correzione e ausiliario sul punto di partenza
         CalcAndSetCorrAuxDir( pCompo, i, false, true) ;
        // se richiesto rapido quando fuori e sono già in aria
         if ( bRapidOnOut  &&  bOutStart) {
           // affondo al punto iniziale
            SetFlag( 0) ;
            if ( AddRapidStart( ptP1) == GDB_ID_NULL)
               return false ;
         }
        // aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
         else if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                   ( m_TParams.m_nType != TT_MILL_NOTIP  ||  LeadInRawIsOk()  ||  m_bStartOutRaw)) {
           // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
            Vector3d vtEscape = vtTool ;
            if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                 ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
               vtEscape.z = 0 ;
               vtEscape.Normalize() ;
            }
            double dNewStElev ;
            if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
               dStElev = min( dStElev, max( dNewStElev - dExtraLen, 0.)) ;
           // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
            bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                     m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
            if ( bAhUnderStart)
               dStElev = max( dStElev - dExtraLen, 0.) ;
           // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
            bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                       m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
            if ( bUhAboveStart)
               dStElev = max( dStElev - dExtraLen, 0.) ;
           // se attacco a zigzag o a spirale, l'elevazione va nell'attacco
            if ( IsLeadInHelixOrZigzag()) {
               ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
               dStElev = - GetLeadInOutToler() ;
            }
           // approccio al punto iniziale
            if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
               return false ;
            }
         }
        // altrimenti, approccio per lame e frese che non lavorano di testa
         else {
           // verifico di entrare in aria
            if ( ! ( bOutStart  ||  m_bStartOutRaw)) {
              // verifico se sono sotto
               double dSawStartElev = 0 ;
               bool bAhUnderStart = false ;
               bool bUhAboveStart = false ;
               bool bSideStart = false ;
               if ( ! bGeomAboveStart) {
                  bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
                                                                      GetRadiusForStartEndElevation(),
                                                                      m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
               }
               else {
                  bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
                                                                        GetRadiusForStartEndElevation(),
                                                                        m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
               }
              // se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
               if ( ! bAhUnderStart  &&  ! bUhAboveStart) {
                  Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
                  Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                  Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                  Vector3d vtAppr2 = vtDir1 ;
                  if ( ! vtAppr2.Normalize())
                     vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
                  double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) + 2 * DELTA_ELEV_RAD ;
                  double dSawStartElev1, dSawStartElev2 ;
                  bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr1, dSawStartElev1) ;
                  bool bOk2 = ! AreSameVectorApprox( vtAppr2, vtAppr1)  &&
                              GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtAppr2, dSawStartElev2) ;
                  if ( bOk1  &&  bOk2) {
                     bool bFirst = ( dSawStartElev1 < 1.3 * dSawStartElev2) ;
                     vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                     dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                     bSideStart = true ;
                  }
                  else if ( bOk1) {
                     vtAppr = vtAppr1 ;
                     dSawStartElev = dSawStartElev1 ;
                     bSideStart = true ;
                  }
                  else if ( bOk2) {
                     vtAppr = vtAppr2 ;
                     dSawStartElev = dSawStartElev2 ;
                     bSideStart = true ;
                  }
               }               
               if ( ! bGeomAboveStart  &&  ! bAhUnderStart  &&  ! bUhAboveStart  &&  ! bSideStart  &&  bOk) {
                  m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                  bOk = false ;
               }
              // aggiungo opportuno approccio
               if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr, true, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                  return false ;
               }
            }
            else {
              // affondo al punto iniziale
               SetFlag( 0) ;
               if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                  return false ;
            }
         }
        // aggiungo attacco
         SetFeed( GetStartFeed()) ;
         if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
            m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
            return false ;
         }
      }
     // imposto versore correzione e ausiliario sul punto di arrivo
      CalcAndSetCorrAuxDir( pCompo, i + 1, false, true) ;
     // se richiesto, imposto indice entità
      if ( bIndex)
         SetIndex( i + 1) ;
     // elaborazioni sulla curva corrente
      if ( pCurve->GetType() == CRV_LINE) {
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         SetFeed( GetFeed()) ;
         if ( bPathTabsEnable) {
            if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
               return false ;
         }
         else if ( bPathOscEnable) {
            if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
               return false ;
         }
         else {
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
               return false ;
         }
      }
      else if ( pCurve->GetType() == CRV_ARC) {
         ICurveArc* pArc = GetCurveArc( pCurve) ;
         SetFeed( GetFeed()) ;
         if ( bPathTabsEnable) {
            if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
               return false ;
         }
         else if ( bPathOscEnable) {
            if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
               return false ;
         }
         else {
            Point3d ptCen = pArc->GetCenter() ;
            double dAngCen = pArc->GetAngCenter() ;
            Vector3d vtN = pArc->GetNormVersor() ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // se ultima entità, uscita e retrazione
      if ( i == nMaxInd) {
        // reset index
         SetIndex( 0) ;
        // dati fine entità
         Point3d ptEnd ;
         pCurve->GetEndPoint( ptEnd) ;
         Vector3d vtEnd = m_vtEndDir ;
        // elevazione sul punto finale
         double dEndElev ;
         if ( GetElevation( m_nPhase, ptEnd + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
            dEndElev = max( dEndElev - dExtraLen, 0.) ;
         else
            dEndElev = dElev ;
        // aggiungo uscita
         Point3d ptP1 ;
         Vector3d vtDir1 ;
         SetFeed( GetEndFeed()) ;
         if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
            m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
            return false ;
         }
        // determino se la fine dell'uscita è fuori dal grezzo
         Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
         if ( ! vtRetr.Normalize())
            vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
         bool bOutEnd = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtRetr, dSafeZ) ;
        // se richiesto rapido quando fuori e sono già in aria
         if ( bRapidOnOut  &&  bOutEnd) {
           // non devo fare alcunché 
         }
        // aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
         else if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                   ( m_TParams.m_nType != TT_MILL_NOTIP  ||  m_bEndOutRaw)) {
           // determino se la fine dell'uscita è sopra il grezzo
            bool bAboveEnd = false ;
            if ( m_bAboveHead) {
               if ( ! m_bTiltingTab)
                  bAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
               else {
                  Vector3d vtCorr = CalcCorrDir( pCompo, nMaxInd + 1, false, true) ;
                  if ( GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtCorr, dSafeZ))
                     dEndElev = min( dEndElev, dElev) ;
               }
            }
           // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
            Vector3d vtEscape = vtTool ;
            if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                 ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
               vtEscape.z = 0 ;
               vtEscape.Normalize() ;
            }
            double dNewEndElev ;
            if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
               dEndElev = min( dEndElev, max( dNewEndElev - dExtraLen, 0.)) ;
           // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
            bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                   m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
            if ( bAhUnderEnd)
               dEndElev = max( dEndElev - dExtraLen, 0.) ;
           // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
            bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                     m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
            if ( bUhAboveEnd)
               dEndElev = max( dEndElev - dExtraLen, 0.) ;
           // aggiungo retrazione
            if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
               return false ;
            }
         }
        // per lame e frese che non lavorano di testa quando è necessario
         else {
            if ( ! ( bOutEnd  ||  m_bEndOutRaw)) {
              // verifico se sono sopra
               bool bGeomAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
              // verifico se sono sotto
               double dSawEndElev = 0 ;
               bool bAhUnderEnd = false ;
               bool bUhAboveEnd = false ;
               bool bSideEnd = false ;
               if ( ! bGeomAboveEnd) {
                  bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
                                                                    GetRadiusForStartEndElevation(),
                                                                    m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
               }
               else {
                  bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, m_TParams.m_dTDiam / 2,
                                                                      GetRadiusForStartEndElevation(),
                                                                      m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
               }
               if ( ! bAhUnderEnd  &&  ! bUhAboveEnd) {
                  Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) - DELTA_ELEV_RAD * vtTool ;
                  Point3d ptTestU = ptTest + m_TParams.m_dDiam * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                  Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                  Vector3d vtRetr2 = vtDir1 ;
                  if ( ! vtRetr2.Normalize())
                     vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1, false, true)) ;
                  double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) + 2 * DELTA_ELEV_RAD ;
                  double dSawEndElev1, dSawEndElev2 ;
                  bool bOk1 = GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr1, dSawEndElev1) ;
                  bool bOk2 = ! AreSameVectorApprox( vtRetr2, vtRetr1)  &&
                              GetElevation( m_nPhase, ptTest + vtWkTip, ptTestU + vtWkTip, vtTool, GetRadiusForStartEndElevation(), dThick, vtRetr2, dSawEndElev2) ;
                  if ( bOk1  &&  bOk2) {
                     bool bFirst = ( dSawEndElev1 < 1.3 * dSawEndElev2) ;
                     vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                     dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                     bSideEnd = true ;
                  }
                  else if ( bOk1) {
                     vtRetr = vtRetr1 ;
                     dSawEndElev = dSawEndElev1 ;
                     bSideEnd = true ;
                  }
                  else if ( bOk2) {
                     vtRetr = vtRetr2 ;
                     dSawEndElev = dSawEndElev2 ;
                     bSideEnd = true ;
                  }
               }
               if ( ! bGeomAboveEnd  &&  ! bAhUnderEnd  &&  ! bUhAboveEnd  &&  ! bSideEnd  &&  bOk) {
                  m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
                  bOk = false ;
               }
              // aggiungo opportuna retrazione
               if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
                  m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev,
                           double dOkStep, bool bStepUp, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
   double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;

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

  // in caso di tabs ne aggiusto i parametri secondo il percorso
   TabData tdTabs ;
   AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
   DBLVECTOR vdTabs ;
  // se ultima passata al contrario
   if ( bPathTabsEnable  &&  ( nStep % 2) == 0) {
      PtrOwner<ICurveComposite> pCopy( pCompo->Clone()) ;
      if ( ! IsNull( pCopy)  &&  pCopy->Invert())
         CalcTabsPositions( pCopy, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;
      else
         bPathTabsEnable = false ;
   }
   else
      CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;

  // in caso di oscillazione ne aggiusto i parametri secondo il percorso
   double dOscRampLen, dOscFlatLen ;
   AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;

  // altri dati del percorso
   int nMaxInd = pCompo->GetCurveCount() - 1 ;

  // ciclo sugli step
   bool bOk = true ;
   for ( int k = 1 ; k <= nStep ; ++ k) {
     // flag direzione (prima passata indice 1)
      bool bInvert = ( ( k % 2) == 0) ;
      int j = ( bStepUp ? nStep - k + 1 : k) ;
      m_dCurrTabsLen = 0 ;
      m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
     // ciclo sulle curve elementari
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
        // copio la curva
         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
         if ( IsNull( pCurve))
            return false ;
         if ( bInvert)
            pCurve->Invert() ;
        // aggiungo affondamento
         pCurve->Translate( - vtTool * ( dDepth - dElev + j * dStep)) ;
        // se prima entità, se primo step approccio e sempre affondo
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart = ( ! bInvert ? m_vtStartDir : -m_vtEndDir) ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
               dStElev = dStep ;
           // determino inizio attacco
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            double dCalcStElev = dStElev ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, ptP1, vtDir1))
               return false ;
           // determino se l'inizio dell'attacco è fuori dal grezzo
            Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
            if ( ! vtAppr.Normalize())
               vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
           // determino se l'inizio dell'attacco è sopra il grezzo
            bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
            bool bAboveStart = false ;
            if ( m_bAboveHead) {
               if ( ! m_bTiltingTab)
                  bAboveStart = bGeomAboveStart ;
               else {
                  if ( bOutStart)
                     dStElev = min( dStElev, dStep) ;
               }
            }
           // imposto versore correzione e ausiliario sul punto di partenza
            CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i), false, true) ;
           // se primo step
            if ( k == 1) {
              // aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
               if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                    ( m_TParams.m_nType != TT_MILL_NOTIP  ||  LeadInRawIsOk()  ||  m_bStartOutRaw  ||  bOutStart)) {
                 // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewStElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
                     dStElev = min( dStElev, dNewStElev) ;
                 // se testa sopra determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se testa sotto determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                             m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se attacco a zigzag o a spirale, l'elevazione va nell'attacco
                  if ( IsLeadInHelixOrZigzag()) {
                     ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
                     dStElev = - GetLeadInOutToler() ;
                  }
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                     return false ;
                  }
               }
              // altrimenti, approccio per lame e frese che non lavorano di testa
               else {
                 // verifico di entrare in aria
                  if ( ! bOutStart) {
                    // verifico se sono sotto
                     double dSawStartElev = 0 ;
                     bool bUnderStart = false ;
                     bool bSideStart = false ;
                     if ( ! bGeomAboveStart) {
                        bUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                          GetRadiusForStartEndElevation(),
                                                                          m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
            
                     }
                    // se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
                     if ( ! bUnderStart) {
                        Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                        Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                        Vector3d vtAppr2 = vtDir1 ;
                        if ( ! vtAppr2.Normalize())
                           vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
                        double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                        double dSawStartElev1, dSawStartElev2 ;
                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
                        if ( bOk1  &&  bOk2) {
                           bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
                           vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                           dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                           bSideStart = true ;
                        }
                        else if ( bOk1) {
                           vtAppr = vtAppr1 ;
                           dSawStartElev = dSawStartElev1 ;
                           bSideStart = true ;
                        }
                        else if ( bOk2) {
                           vtAppr = vtAppr2 ;
                           dSawStartElev = dSawStartElev2 ;
                           bSideStart = true ;
                        }
                     }               
                     if ( ! bGeomAboveStart  &&  ! bUnderStart  &&  ! bSideStart  &&  bOk) {
                        m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                        bOk = false ;
                     }
                    // aggiungo opportuno approccio
                     if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr, true, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                        return false ;
                     }
                  }
                  else {
                    // affondo al punto iniziale
                     SetFlag( 0) ;
                     if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                        return false ;
                  }
               }
            }
           // altrimenti, affondo al punto iniziale
            else {
              // considero come elevazione lo step dalla passata precedente
               dStElev = dStep ;
              // se lama o fresa che non lavora di testa
               if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0  ||  m_TParams.m_nType == TT_MILL_NOTIP) {
                  SetFeed( GetStartFeed()) ;
                 // eventuale movimento parallelo all'asse utensile fatto fuori
                  Point3d ptCurr ;
                  if ( ! GetCurrPos( ptCurr))
                     return false ;
                  Vector3d vtToolOrt = OrthoCompo( ptP1 - ptCurr, vtTool) ;
                  if ( vtToolOrt.Len() > 100 * EPS_SMALL) {
                     if ( AddLinearMove( ptP1 - vtToolOrt, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                        return false ;
                  }
                 // movimento standard
                  if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                     return false ;
               }
              // se attacco a zigzag o a spirale, non affondo
               else if ( IsLeadInHelixOrZigzagOrGlide()) {
                  ptP1 += vtTool * ( dStElev + GetLeadInOutToler()) ;
                  dStElev = - GetLeadInOutToler() ;
               }
              // altrimenti, affondo in feed opportuna
               else {
                  bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
                  SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
                  if ( ! SameAsCurrPos( ptP1)  &&  AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                     return false ;
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
               return false ;
            }
         }
        // imposto versore correzione e ausiliario sul punto di arrivo
         CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1), false, true) ;
        // elaborazioni sulla curva corrente
         if ( pCurve->GetType() == CRV_LINE) {
            ICurveLine* pLine = GetCurveLine( pCurve) ;
            SetFeed( GetFeed()) ;
            if ( j == nStep  &&  bPathTabsEnable) {
               if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
                  return false ;
            }
            else if ( j == nStep  &&  bPathOscEnable) {
               if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
                  return false ;
            }
            else {
               Point3d ptP3 = pLine->GetEnd() ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
         }
         else if ( pCurve->GetType() == CRV_ARC) {
            ICurveArc* pArc = GetCurveArc( pCurve) ;
            SetFeed( GetFeed()) ;
            if ( j == nStep  &&  bPathTabsEnable) {
               if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
                  return false ;
            }
            else if ( j == nStep  &&  bPathOscEnable) {
               if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
                  return false ;
            }
            else {
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
         }
        // se ultima entità, uscita e se ultimo step retrazione
         if ( i == nMaxInd) {
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd = ( ! bInvert ? m_vtEndDir : -m_vtStartDir) ;
           // elevazione sul punto finale
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
           // se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
            Point3d ptP1 = ptEnd ;
            Vector3d vtDir1 ;
            if ( ! IsLeadInHelixOrZigzag()  ||  k == nStep) {
               if ( k != nStep  &&  GetLeadInType() == MILL_LI_GLIDE)
                  dEndElev = - GetLeadInOutToler() ;
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1, vtDir1)) {
                  m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
                  return false ;
               }
            }
           // determino se la fine dell'uscita è fuori dal grezzo
            Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
            if ( ! vtRetr.Normalize())
               vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
            bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
           // per lame e frese che non lavorano di testa quando ancora dentro aggiungo retrazione se necessaria
            if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0  ||
                 ( m_TParams.m_nType == TT_MILL_NOTIP  &&  ! m_bEndOutRaw  &&  ! bOutEnd)) {
               if ( ! bOutEnd) {
                 // verifico se sono sopra
                  bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
                 // verifico se sono sotto
                  double dSawEndElev = 0 ;
                  bool bUnderEnd = false ;
                  bool bSideEnd = false ;
                  if ( ! bGeomAboveEnd) {
                     bUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                     GetRadiusForStartEndElevation(),
                                                                     m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
                  }
                  if ( ! bUnderEnd) {
                     Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                     Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                     Vector3d vtRetr2 = vtDir1 ;
                     if ( ! vtRetr2.Normalize())
                        vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1, false, true)) ;
                     double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                     double dSawEndElev1, dSawEndElev2 ;
                     bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
                     bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
                     if ( bOk1  &&  bOk2) {
                        bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
                        vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                        dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                        bSideEnd = true ;
                     }
                     else if ( bOk1) {
                        vtRetr = vtRetr1 ;
                        dSawEndElev = dSawEndElev1 ;
                        bSideEnd = true ;
                     }
                     else if ( bOk2) {
                        vtRetr = vtRetr2 ;
                        dSawEndElev = dSawEndElev2 ;
                        bSideEnd = true ;
                     }
                  }
                  if ( ! bGeomAboveEnd  &&  ! bUnderEnd  &&  ! bSideEnd  &&  bOk) {
                     m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
                     bOk = false ;
                  }
                 // se finale oppure dentro il materiale, aggiungo opportuna retrazione
                  if ( ( k == nStep  ||  ! bUnderEnd)  &&
                       ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr)) {
                     m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                     return false ;
                  }
               }
            }
           // altrimenti frese e se ultimo step aggiungo retrazione
            else if ( k == nStep) {
              // determino se la fine dell'uscita è sopra il grezzo
               bool bAboveEnd = false ;
               if ( m_bAboveHead)  {
                  if ( ! m_bTiltingTab)
                     bAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
                  else {
                     Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? 0 : nMaxInd + 1), false, true) ;
                     if ( GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ))
                        dEndElev = min( dEndElev, dElev) ;
                  }
               }
              // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
               Vector3d vtEscape = vtTool ;
               if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                    ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                  vtEscape.z = 0 ;
                  vtEscape.Normalize() ;
               }
               double dNewEndElev ;
               if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
                  dEndElev = min( dEndElev, dNewEndElev) ;
              // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
               bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                      m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
              // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
               bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                        m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
              // aggiungo retrazione
               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                  return false ;
               }
            }
         }
      }
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev,
                           double dOkStep, bool bStepUp, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
   double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;

  // in caso di tabs ne aggiusto i parametri secondo il percorso
   TabData tdTabs ;
   AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
   DBLVECTOR vdTabs ;
   CalcTabsPositions( pCompo, dDepth, bPathTabsEnable, tdTabs, vdTabs) ;

  // in caso di oscillazione ne aggiusto i parametri secondo il percorso
   double dOscRampLen, dOscFlatLen ;
   AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;

  // percorso speciale : chiuso e con attacco a spirale o zigzag
   bool bSpecial = ( pCompo->IsClosed() && IsLeadInHelixOrZigzagOrGlide()) ;

  // percorso senza retrazioni intermedie : chiuso e con attacco e uscita con punti esterni coincidenti
   bool bMidRetract = true ;
   if ( pCompo->IsClosed()) {
      int nLiType = GetLeadInType() ;
      int nLoType = GetLeadOutType() ;
      if ( nLiType == MILL_LI_NONE  &&  ( nLoType == MILL_LO_NONE  ||  nLoType == MILL_LO_AS_LI))
         bMidRetract = false ;
      if ( nLiType == MILL_LI_GLIDE)
         bMidRetract = false ;
      if ( ( nLiType == MILL_LI_TANGENT  ||  nLiType == MILL_LI_LINEAR  ||  nLiType == MILL_LI_TG_PERP)  &&
           nLoType == MILL_LO_AS_LI  &&
           abs( m_Params.m_dLiTang) < EPS_SMALL)
         bMidRetract = false ;
      if ( ( nLiType == MILL_LI_TANGENT  ||  nLiType == MILL_LI_LINEAR  ||  nLiType == MILL_LI_TG_PERP)  &&
           ( nLoType == MILL_LO_TANGENT  ||  nLoType == MILL_LO_LINEAR  ||  nLoType == MILL_LO_PERP_TG)  &&
           abs( m_Params.m_dLiTang) < EPS_SMALL  &&
           abs( m_Params.m_dLoTang) < EPS_SMALL  &&
           abs( m_Params.m_dLiPerp - m_Params.m_dLoPerp) < EPS_SMALL)
         bMidRetract = false ;
   }

  // determino punti di inizio e fine
   Point3d ptStart ;
   pCompo->GetStartPoint( ptStart) ;
   ptStart -= vtTool * dDepth ;
   Vector3d vtStart = m_vtStartDir ;
   Point3d ptPs ;
   Vector3d vtDirs ;
   CalcLeadInStart( ptStart, vtStart, vtTool, dElev, false, pCompo, ptPs, vtDirs) ;
   Vector3d vtCs = CalcCorrDir( pCompo, 0, false, true) ;
   Point3d ptEnd ;
   pCompo->GetEndPoint( ptEnd) ;
   ptEnd -= vtTool * dDepth ;
   Vector3d vtEnd = m_vtEndDir ;
   Point3d ptPe ;
   CalcLeadOutEnd( ptEnd, vtEnd, vtTool, dElev, false, pCompo, ptPe) ;
   Vector3d vtCe = CalcCorrDir( pCompo, pCompo->GetCurveCount(), false, true) ;
  // verifico se attacco e uscita entrambi sopra o sotto il grezzo
   bool bAhAboveStartEnd = false ;
   bool bUhBelowStartEnd = false ;
   if ( m_bAboveHead)
      bAhAboveStartEnd = GetPointAboveRaw( ptPs, vtTool) && GetPointAboveRaw( ptPe, vtTool) ;
   else
      bUhBelowStartEnd = GetPointBelowRaw( ptPs, vtTool) && GetPointBelowRaw( ptPe, vtTool) ;
  // verifico se collegamento diretto tra ingresso e uscita è fuori dal grezzo
   bool bSafeDirLinkStartEnd = ( bAhAboveStartEnd  ||  bUhBelowStartEnd  ||
                                 ( ! bMidRetract  &&  m_bStartOutRaw  &&  m_bEndOutRaw)) ;
   if ( ! bSafeDirLinkStartEnd) {
     // verifica dei punti intermedi
      bool bIsOut = true ;
      int nStep = Clamp( int( Dist( ptPs, ptPe) / m_TParams.m_dDiam), 4, 16) ;
      for ( int i = 1 ; i < nStep ; ++ i) {
         double dCoeff = double( i) / nStep ;
         Point3d ptPm = Media( ptPs, ptPe, dCoeff) ;
         Vector3d vtCm = Media( vtCs, vtCe, dCoeff) ;
         if ( ! vtCm.Normalize())
            vtCm = vtCs ;
         if ( ! GetSimplePointOutOfRaw( ptPm, vtTool, vtCm)  &&
              ( m_TParams.m_nType == TT_MILL_STD  ||  ! GetSimplePointOutOfRaw( ptPm, vtTool, vtTool))) {
            bIsOut = false ;
            break ;
         }
      }
      if ( bIsOut)
         bSafeDirLinkStartEnd = true ;
   }

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

  // ciclo sugli step
   bool bOk = true ;
   for ( int k = 1 ; k <= nStep ; ++ k) {
      int j = ( bStepUp ? nStep - k + 1 : k) ;
      m_dCurrTabsLen = 0 ;
      m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
     // se percorso chiuso e attacco ad inseguimento sposto inizio
      if ( k > 1  &&  pCompo->IsClosed()  &&  GetLeadInType() == MILL_LI_GLIDE) {
         double dU ;
         if ( pCompo->GetParamAtLength( m_Params.m_dLiTang, dU)) {
            const_cast<ICurveComposite*>( pCompo)->ChangeStartPoint( dU) ;
            const_cast<ICurveComposite*>( pCompo)->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false) ;
            VerifyArcs( const_cast<ICurveComposite*>( pCompo)) ;
         }
      }
     // ciclo sulle curve elementari
      int nMaxInd = pCompo->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCrvC = pCompo->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à, approccio e affondo
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart = m_vtStartDir ;
            // pCurve->GetStartDir( vtStart) ;
           // imposto versore correzione e ausiliario sul punto di partenza
            CalcAndSetCorrAuxDir( pCompo, i, false, true) ;
           // punto inizio attacco
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            double dCalcStElev = 0 ;
           // se speciale e step intermedio
            if ( bSpecial  &&  k > 1) {
               ptP1 = ptStart + dStep * vtTool ;
            }
           // altrimenti
            else {
              // determino elevazione su inizio attacco
               double dStElev ;
               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = dElev ;
               if ( ! bSafeDirLinkStartEnd)
                  dStElev = max( dStElev, j * dStep) ;
              // determino inizio attacco
               dCalcStElev = dStElev ;
               if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
                  return false ;
              // determino se l'inizio dell'attacco è fuori dal grezzo
               Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
               if ( ! vtAppr.Normalize())
                  vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
              // aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
               if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                    ( m_TParams.m_nType != TT_MILL_NOTIP  ||  LeadInRawIsOk()  ||  m_bStartOutRaw)) {
                 // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewStElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
                     if ( bAhAboveStartEnd  ||  bUhBelowStartEnd)
                        dStElev = min( dStElev, dNewStElev) ;
                     else
                        dStElev = max( dStElev, dNewStElev) ;
                  }
                  if ( bSafeDirLinkStartEnd  &&  m_bTiltingTab)
                     dStElev = min( dStElev, j * dStep) ;
                 // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                             m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se attacco a zigzag o a spirale, l'elevazione va nell'attacco
                  if ( IsLeadInHelixOrZigzag()) {
                     ptP1 += vtTool * ( dStElev - ( j - 1) * dStep) ;
                     dStElev = ( j - 1) * dStep ;
                  }
                 // approccio standard al punto iniziale
                  if ( k == 1  ||  bMidRetract) {
                     if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart,
                                         bAhAboveStartEnd || bUhBelowStartEnd, k == 1, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                        return false ;
                     }
                  }
                 // altrimenti approccio diretto al punto iniziale
                  else {
                     if ( ! AddDirectApproach( ptP1, bSplitArcs)) {
                        m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                        return false ;
                     }
                  }
               }
              // altrimenti, approccio per lame e frese che non lavorano di testa
               else {
                 // flag necessità movimento preliminare di inserzione in direzione utensile
                  bool bAddInsert = ( k > 1  &&  ! bSafeDirLinkStartEnd) ;
                 // verifico di entrare in aria
                  if ( ! bOutStart) {
                    // verifico se sono sopra
                     bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
                    // verifico se sono sotto
                     double dSawStartElev = 0 ;
                     bool bAhUnderStart = false ;
                     bool bUhAboveStart = false ;
                     bool bSideStart = false ;
                     if ( ! bGeomAboveStart) {
                        bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                            GetRadiusForStartEndElevation(),
                                                                            m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
                     }
                     else {
                        bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                              GetRadiusForStartEndElevation(),
                                                                              m_TParams.m_dLen, true, dSafeZ, vtAppr, dSawStartElev) ;
                     }
                    // se non sono sotto, verifico se posso allontanarmi nel piano lama (meglio se in orizzontale)
                     if ( ! bAhUnderStart  &&  ! bUhAboveStart) {
                        Point3d ptTest = ptP1 - MIN_SAFEDIST * vtTool ;
                        Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                        Vector3d vtAppr2 = vtDir1 ;
                        if ( ! vtAppr2.Normalize())
                           vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i, false, true)) ;
                        double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                        double dSawStartElev1 = 0, dSawStartElev2 = 0 ;
                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
                        if ( bOk1  &&  bOk2) {
                           bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
                           vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                           dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                           bSideStart = true ;
                        }
                        else if ( bOk1) {
                           vtAppr = vtAppr1 ;
                           dSawStartElev = dSawStartElev1 ;
                           bSideStart = true ;
                        }
                        else if ( bOk2) {
                           vtAppr = vtAppr2 ;
                           dSawStartElev = dSawStartElev2 ;
                           bSideStart = true ;
                        }
                     }  
                     if ( bSideStart)
                        bMidRetract = true ;
                     if ( ! bGeomAboveStart  &&  ! bAhUnderStart  &&  ! bUhAboveStart  &&  ! bSideStart  &&  bOk) {
                        m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                        bOk = false ;
                     }

                    // aggiungo opportuno approccio
                     if ( ! AddSawBladeSideApproach( ptP1, vtAppr, vtTool, dSafeZ, dSawStartElev, dStElev, dAppr,
                                                     k == 1, bSplitArcs, bAddInsert && bMidRetract)) {
                        m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                        return false ;
                     }
                  }
                  else {
                     SetFlag( 0) ;
                     bool bFirst = ( k == 1) ;
                    // se necessario inserimento
                     if ( bAddInsert) {
                        Point3d ptInsert = ptP1 + ( dStElev + dSafeZ) * vtTool ;
                        if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
                           return false ;
                        if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
                           return false ;
                     }
                    // altrimenti direttamente al punto iniziale
                     else {
                        if ( AddRapidStartOrMove( ptP1, bFirst, bSplitArcs) == GDB_ID_NULL)
                           return false ;
                     }
                  }
               }
            }
           // aggiungo attacco
            SetFeed( GetStartFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
               return false ;
            }
         }
        // imposto versore correzione e ausiliario sul punto di arrivo
         CalcAndSetCorrAuxDir( pCompo, i + 1, false, true) ;
        // elaborazioni sulla curva corrente
         if ( pCurve->GetType() == CRV_LINE) {
            ICurveLine* pLine = GetCurveLine( pCurve) ;
            SetFeed( GetFeed()) ;
            if ( j == nStep  &&  bPathTabsEnable) {
               if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
                  return false ;
            }
            else if ( j == nStep  &&  bPathOscEnable) {
               if ( ! AddOscillLine( pLine, vtTool, dOscRampLen, dOscFlatLen))
                  return false ;
            }
            else {
               Point3d ptP3 = pLine->GetEnd() ;
               if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                  return false ;
            }
         }
         else if ( pCurve->GetType() == CRV_ARC) {
            ICurveArc* pArc = GetCurveArc( pCurve) ;
            SetFeed( GetFeed()) ;
            if ( j == nStep  &&  bPathTabsEnable) {
               if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
                  return false ;
            }
            else if ( j == nStep  &&  bPathOscEnable) {
               if ( ! AddOscillArc( pArc, vtTool, dOscRampLen, dOscFlatLen))
                  return false ;
            }
            else {
               Point3d ptCen = pArc->GetCenter() ;
               double dAngCen = pArc->GetAngCenter() ;
               Vector3d vtN = pArc->GetNormVersor() ;
               Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                  return false ;
            }
         }
        // se ultima entità, uscita e retrazione
         if ( i == nMaxInd) {
           // se speciale e step intermedio salto uscita e retrazione
            if ( bSpecial  &&  k != nStep)
               continue ;
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd = m_vtEndDir ;
            // pCurve->GetEndDir( vtEnd) ;
           // elevazione sul punto finale
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
               dEndElev = dElev ;
            if ( ! bSafeDirLinkStartEnd)
               dEndElev = max( dEndElev, j * dStep) ;
           // aggiungo uscita
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
               m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
               return false ;
            }
           // se step finale o intermedi con retrazione
            if ( k == nStep  ||  bMidRetract  ||  ! bSafeDirLinkStartEnd) {
              // determino se la fine dell'uscita è fuori dal grezzo
               Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
               if ( ! vtRetr.Normalize())
                  vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
               bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
              // aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
               if ( ( m_TParams.m_nType & TF_MILL) != 0  && 
                    ( m_TParams.m_nType != TT_MILL_NOTIP  ||  m_bEndOutRaw)) {
                 // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewEndElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
                     if ( bAhAboveStartEnd  ||  bUhBelowStartEnd)
                        dEndElev = min( dEndElev, dNewEndElev) ;
                     else if ( dNewEndElev > EPS_SMALL)
                        dEndElev = max( dEndElev, dNewEndElev) ;
                  }
                  if ( bSafeDirLinkStartEnd  &&  m_bTiltingTab)
                     dEndElev = min( dEndElev, j * dStep) ;
                 // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                         m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // aggiungo retrazione
                  if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAhAboveStartEnd || bUhBelowStartEnd, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                     return false ;
                  }
               }
              // per lame e frese che non lavorano di testa quando è necessario
               else {
                 // flag necessità movimento successivo di estrazione in direzione utensile
                  bool bAddExtract = ( k < nStep  &&  ! bSafeDirLinkStartEnd) ;
                 // se non è già fuori dal pezzo...
                  if ( ! bOutEnd) {
                    // verifico se sono sopra
                     bool bGeomAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
                    // verifico se sono sotto
                     double dSawEndElev = 0 ;
                     bool bAhUnderEnd = false ;
                     bool bUhAboveEnd = false ;
                     bool bSideEnd = false ;
                     if ( ! bGeomAboveEnd) {
                        bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                          GetRadiusForStartEndElevation(),
                                                                          m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
                     }
                     else {
                        bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, m_TParams.m_dTDiam / 2,
                                                                            GetRadiusForStartEndElevation(),
                                                                            m_TParams.m_dLen, true, dSafeZ, vtRetr, dSawEndElev) ;
                     }
                     if ( ! bAhUnderEnd  &&  ! bUhAboveEnd) {
                        Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                        Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
                        Vector3d vtRetr2 = vtDir1 ;
                        if ( ! vtRetr2.Normalize())
                           vtRetr2 = CalcCorrDir( pCompo, i + 1, false, true) ;
                        double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                        double dSawEndElev1, dSawEndElev2 ;
                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
                        if ( bOk1  &&  bOk2) {
                           bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
                           vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                           dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                           bSideEnd = true ;
                        }
                        else if ( bOk1) {
                           vtRetr = vtRetr1 ;
                           dSawEndElev = dSawEndElev1 ;
                           bSideEnd = true ;
                        }
                        else if ( bOk2) {
                           vtRetr = vtRetr2 ;
                           dSawEndElev = dSawEndElev2 ;
                           bSideEnd = true ;
                        }
                     }
                     if ( bSideEnd)
                        bMidRetract = true ;
                     if ( ! bGeomAboveEnd  &&  ! bAhUnderEnd  &&  ! bUhAboveEnd  &&  ! bSideEnd  &&  bOk) {
                        m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
                        bOk = false ;
                     }
                    // aggiungo opportuna retrazione
                     if ( ! AddSawBladeSideRetract( ptP1, vtRetr, vtTool, dSafeZ, dSawEndElev, dEndElev, dAppr, bAddExtract && bMidRetract)) {
                        m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                        return false ;
                     }
                  }
                 // se richiesta estrazione in direzione utensile
                  else if ( bAddExtract) {
                     Point3d ptExtract = ptP1 + ( dEndElev + dSafeZ) * vtTool ;
                     if ( AddRapidMove( ptExtract, bSplitArcs) == GDB_ID_NULL)
                        return false ;
                  }
               }
            }
         }
      }
   }
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                           double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;
   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;
   double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;

   // se attacco ad inseguimento (per ora nullo), parto sopra di elevazione in attacco
   double dStart = 0 ;
   if ( m_Params.m_nLeadInType == MILL_LI_NONE)
      dStart = m_Params.m_dLiElev ;

  // in caso di oscillazione ne aggiusto i parametri secondo il percorso
   double dOscRampLen, dOscFlatLen ;
   AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;

  // imposto flag di percorso chiuso
   bool bClosed = pCompo->IsClosed() ;

  // determino numero e affondamento degli step
   int nStep = max( 1, static_cast<int>( ceil( ( dElev + dStart) / ( bClosed ? dOkStep : dOkStep / 2)))) ;
   if ( m_TParams.m_nType == TT_MILL_POLISHING)
      nStep = max( 1, nStep - 1) ;
   double dStep = ( dElev + dStart) / nStep ;

  // determino dati del percorso
   double dTotLen ; pCompo->GetLength( dTotLen) ;
   int nMaxInd = pCompo->GetCurveCount() - 1 ;

  // se chiuso -> sempre in avanti
   if ( bClosed) {
     // ciclo sugli step
      for ( int j = 0 ; j <= nStep ; ++ j) {
        // ciclo sulle curve elementari
         m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
         double dCurrLen = 0 ;
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pCompo->GetCurve( i) ;
           // affondamento a inizio curva
            Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
           // affondamento a fine curva
            double dCrvLen ; pCrvC->GetLength( dCrvLen) ;
            dCurrLen += dCrvLen ;
            Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart +  min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
           // se prima entità di primo step, approccio e affondo
            if ( i == 0  &&  j == 0) {
              // dati inizio entità
               Point3d ptStart ;
               pCrvC->GetStartPoint( ptStart) ;
               ptStart -= vtStaDepth ;
               Vector3d vtStart = m_vtStartDir ;
               // pCrvC->GetStartDir( vtStart) ;
              // determino elevazione su inizio attacco
               double dStElev ;
               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = 0 ;
               dStElev -= dStart ;
              // determino inizio attacco
               Point3d ptP1 ;
               Vector3d vtDir1 ;
               double dCalcStElev = dStElev ;
               if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, ptP1, vtDir1))
                  return false ;
              // determino se l'inizio dell'attacco è fuori dal grezzo
               Vector3d vtCorr = CalcCorrDir( pCompo, i) ;
               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
              // determino se l'inizio dell'attacco è sopra il grezzo
               bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
              // imposto versore correzione e ausiliario sul punto di partenza
               CalcAndSetCorrAuxDir( pCompo, i) ;
              // aggiungo approccio per frese normali
               if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
                 // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewStElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
                     dStElev = min( dStElev, dNewStElev) ;
                 // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                             m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                     return false ;
                  }
               }
              // altrimenti, affondo al punto iniziale per lame
               else {
                 // verifico di entrare in aria
                  if ( ! bOutStart) {
                     m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                     return false ;
                  }
                 // eseguo affondamento
                  SetFlag( 0) ;
                  if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                     return false ;
               }
              // aggiungo attacco
               SetFeed( GetStartFeed()) ;
               if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, false, pCompo, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
                  return false ;
               }
            }
           // imposto versore correzione e ausiliario sul punto di arrivo
            CalcAndSetCorrAuxDir( pCompo, i + 1) ;
           // elaborazioni sulla curva corrente
            if ( pCrvC->GetType() == CRV_LINE) {
               const ICurveLine* pLine = GetCurveLine( pCrvC) ;
               SetFeed( GetFeed()) ;
               if ( j == nStep  &&  bPathOscEnable) {
                  PtrOwner<ICurveLine> pTmpLine( pLine->Clone()) ;
                  if ( IsNull( pTmpLine))
                     return false ;
                  pTmpLine->Translate( -vtStaDepth) ;
                  if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen))
                     return false ;
               }
               else {
                  Point3d ptP3 = pLine->GetEnd() ;
                  ptP3 -= vtEndDepth ;
                  if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                     return false ;
               }
            }
            else if ( pCrvC->GetType() == CRV_ARC) {
               const ICurveArc* pArc = GetCurveArc( pCrvC) ;
               SetFeed( GetFeed()) ;
               if ( j == nStep  &&  bPathOscEnable) {
                  PtrOwner<ICurveArc> pTmpArc( pArc->Clone()) ;
                  if ( IsNull( pTmpArc))
                     return false ;
                  pTmpArc->Translate( -vtStaDepth) ;
                  if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen))
                     return false ;
               }
               else {
                  Point3d ptCen = pArc->GetCenter() ;
                  ptCen -= vtStaDepth ;
                  double dAngCen = pArc->GetAngCenter() ;
                  Vector3d vtN = pArc->GetNormVersor() ;
                  Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
                  ptP3 -= vtEndDepth ;
                  if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                     return false ;
               }
            }
           // se ultima entità di ultimo step, uscita e retrazione
            if ( i == nMaxInd  &&  j == nStep) {
              // dati fine entità
               Point3d ptEnd ;
               pCrvC->GetEndPoint( ptEnd) ;
               ptEnd -= vtEndDepth ;
               Vector3d vtEnd = m_vtEndDir ;
               // pCrvC->GetEndDir( vtEnd) ;
              // elevazione sul punto finale
               double dEndElev ;
               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
              // aggiungo uscita
               Point3d ptP1 ;
               Vector3d vtDir1 ;
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, false, pCompo, bSplitArcs, ptP1, vtDir1)) {
                  m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
                  return false ;
               }
              // aggiungo retrazione per frese normali
               if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
                 // determino se la fine dell'uscita è sopra il grezzo
                  bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
                 // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewEndElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
                     dEndElev = min( dEndElev, dNewEndElev) ;
                 // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                         m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // aggiungo retrazione
                  if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                     return false ;
                  }
               }
              // per lame non è necessario
            }
         }
      }
   }

  // altrimenti aperto -> avanti e indietro
   else {
     // ciclo sugli step
      for ( int j = 0 ; j <= nStep ; ++ j) {
        // flag direzione (prima passata indice 0)
         bool bInvert = ( ( j % 2) == 1) ;
        // ciclo sulle curve elementari
         m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
         double dCurrLen = 0 ;
         for ( int i = 0 ; i <= nMaxInd ; ++ i) {
           // curva corrente
            const ICurve* pCrvC = pCompo->GetCurve( ( bInvert ? nMaxInd - i : i)) ;
           // copio la curva
            PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
            if ( IsNull( pCurve))
               return false ;
            if ( bInvert)
               pCurve->Invert() ;
           // affondamento a inizio curva
            Vector3d vtStaDepth = vtTool * ( dDepth - dElev - dStart + min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
           // affondamento a fine curva
            double dCrvLen ; pCrvC->GetLength( dCrvLen) ;
            dCurrLen += dCrvLen ;
            Vector3d vtEndDepth = vtTool * ( dDepth - dElev - dStart +  min((( j + dCurrLen / dTotLen) * dStep), dElev + dStart)) ;
           // se prima entità di primo step, approccio e affondo
            if ( i == 0  &&  j == 0) {
              // dati inizio entità
               Point3d ptStart ;
               pCurve->GetStartPoint( ptStart) ;
               ptStart -= vtStaDepth ;
               Vector3d vtStart = m_vtStartDir ;
               // pCurve->GetStartDir( vtStart) ;
              // determino elevazione su inizio attacco
               double dStElev ;
               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = dElev ;
               dStElev -= dStart ;
              // determino inizio attacco
               Point3d ptP1 ;
               Vector3d vtDir1 ;
               double dCalcStElev = dStElev ;
               if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, ptP1, vtDir1))
                  return false ;
              // determino se l'inizio dell'attacco è fuori dal grezzo
               Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
              // determino se l'inizio dell'attacco è sopra il grezzo
               bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
              // imposto versore correzione e ausiliario sul punto di partenza
               CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
              // aggiungo approccio per frese normali
               if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
                 // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewStElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
                     dStElev = min( dStElev, dNewStElev) ;
                 // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                             m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
                 // approccio al punto iniziale
                  if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dExtrAppr, bOutStart, bAboveStart, true, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2309, "Error in Milling : Approach not computable") ;
                     return false ;
                  }
               }
              // altrimenti, affondo per lame
               else {
                  SetFlag( 0) ;
                  if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                     return false ;
               }
              // aggiungo attacco
               SetFeed( GetStartFeed()) ;
               if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pCompo, bSplitArcs)) {
                  m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
                  return false ;
               }
            }
           // imposto versore correzione e ausiliario sul punto di arrivo
            CalcAndSetCorrAuxDir( pCompo, ( bInvert ? nMaxInd - i : i + 1)) ;
           // elaborazioni sulla curva corrente
            if ( pCurve->GetType() == CRV_LINE) {
               ICurveLine* pLine = GetCurveLine( pCurve) ;
               SetFeed( GetFeed()) ;
               if ( j == nStep  &&  bPathOscEnable) {
                  PtrOwner<ICurveLine> pTmpLine( pLine->Clone()) ;
                  if ( IsNull( pTmpLine))
                     return false ;
                  pTmpLine->Translate( -vtStaDepth) ;
                  if ( ! AddOscillLine( pTmpLine, vtTool, dOscRampLen, dOscFlatLen))
                     return false ;
               }
               else {
                  Point3d ptP3 = pLine->GetEnd() ;
                  ptP3 -= vtEndDepth ;
                  if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
                     return false ;
               }
            }
            else if ( pCurve->GetType() == CRV_ARC) {
               ICurveArc* pArc = GetCurveArc( pCurve) ;
               SetFeed( GetFeed()) ;
               if ( j == nStep  &&  bPathOscEnable) {
                  PtrOwner<ICurveArc> pTmpArc( pArc->Clone()) ;
                  if ( IsNull( pTmpArc))
                     return false ;
                  pTmpArc->Translate( -vtStaDepth) ;
                  if ( ! AddOscillArc( pTmpArc, vtTool, dOscRampLen, dOscFlatLen))
                     return false ;
               }
               else {
                  Point3d ptCen = pArc->GetCenter() ;
                  ptCen -= vtStaDepth ;
                  double dAngCen = pArc->GetAngCenter() ;
                  Vector3d vtN = pArc->GetNormVersor() ;
                  Point3d ptP3 ;
                  pArc->GetEndPoint( ptP3) ;
                  ptP3 -= vtEndDepth ;
                  if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
                     return false ;
               }
            }
           // se ultima entità di ultimo step, uscita e retrazione
            if ( i == nMaxInd  &&  j == nStep) {
              // dati fine entità
               Point3d ptEnd ;
               pCurve->GetEndPoint( ptEnd) ;
               ptEnd -= vtEndDepth ;
               Vector3d vtEnd = m_vtEndDir ;
               // pCurve->GetEndDir( vtEnd) ;
              // elevazione sul punto finale
               double dEndElev ;
               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
              // aggiungo uscita
               Point3d ptP1 ;
               Vector3d vtDir1 ;
               SetFeed( GetEndFeed()) ;
               if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1, vtDir1)) {
                  m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
                  return false ;
               }
              // aggiungo retrazione per frese normali
               if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
                 // determino se la fine dell'uscita è sopra il grezzo
                  bool bAboveEnd = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
                 // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
                  Vector3d vtEscape = vtTool ;
                  if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                       ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
                     vtEscape.z = 0 ;
                     vtEscape.Normalize() ;
                  }
                  double dNewEndElev ;
                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
                     dEndElev = min( dEndElev, dNewEndElev) ;
                 // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                         m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
                  bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                           m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
                 // aggiungo retrazione
                  if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
                     m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
                     return false ;
                  }
               }
              // per lame non è necessario
            }
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
class LeadIOStatus
{
   public :
      LeadIOStatus( Milling* pMill)
         {  m_pMill = pMill ;
            m_dLiPerp = m_pMill->m_Params.m_dLiPerp ;
            m_dLiTang = m_pMill->m_Params.m_dLiTang ;
            m_dLoPerp = m_pMill->m_Params.m_dLoPerp ;
            m_dLoTang = m_pMill->m_Params.m_dLoTang ;
         }
      ~LeadIOStatus( void)
         {  Restore() ;
         }
      void Restore( void)
         {  m_pMill->m_Params.m_dLiPerp = m_dLiPerp ;
            m_pMill->m_Params.m_dLiTang = m_dLiTang ;
            m_pMill->m_Params.m_dLoPerp = m_dLoPerp ;
            m_pMill->m_Params.m_dLoTang = m_dLoTang ;
         }
      
   private :
      Milling* m_pMill ;
      double m_dLiPerp ;
      double m_dLiTang ;
      double m_dLoPerp ;
      double m_dLoTang ;
} ;

//----------------------------------------------------------------------------
bool
Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                              double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;

  // recupero eventuale superficie trimesh chiusa per trim/extend
   int nTriExtCstm = GDB_ID_NULL ;
   int nTesId ;
   if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
      const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
      if ( pTes != nullptr  &&  pTes->IsClosed())
         nTriExtCstm = nTesId ;
   }

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

  // gestione parametri di attacco/uscita (con backup per ripristino all'uscita)
   LeadIOStatus LioStatus( this) ;
   bool bAdjustLiPerp = ( m_Params.m_dLiPerp > 10 * EPS_SMALL) ;
   if ( bAdjustLiPerp) {
      double dNewLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ;
      m_Params.m_dLiTang *= dNewLiPerp / m_Params.m_dLiPerp ;
      m_Params.m_dLiPerp = dNewLiPerp ;
   }
   bool bAdjustLoPerp = ( m_Params.m_dLoPerp > 10 * EPS_SMALL) ;
   if ( bAdjustLoPerp) {
      double dNewLoPerp = max( 0., m_Params.m_dLoPerp - ( nStep - 1) * dStep) ;
      m_Params.m_dLoTang *= dNewLoPerp / m_Params.m_dLoPerp ;
      m_Params.m_dLoPerp = dNewLoPerp ;
   }

  // ciclo sugli step
   for ( int j = 1 ; j <= nStep ; ++ j) {
     // flag direzione
      bool bInvert = ( (( nStep - j) % 2) == 1) ;
     // copio la curva
      PtrOwner<ICurveComposite> pMyCompo( pCompo->Clone()) ;
      if ( IsNull( pMyCompo))
         return false ;
     // eseguo offset ed eventuale inversione
      double dSignOffs = ( dElev - j * dStep) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ;
      if ( ! CalcOffset( pMyCompo, dSignOffs))
         return false ;
      if ( bInvert)
         pMyCompo->Invert() ;
     // eventuale trim/extend con la superficie indicata
      if ( nTriExtCstm != GDB_ID_NULL) {
        // trim con ripristino dell'originale in caso di errore
         PtrOwner<ICurveComposite> pMyCopy( pMyCompo->Clone()) ;
         if ( ! TrimExtendCurveToClosedStm( pMyCompo, nTriExtCstm, bInvert))
            pMyCompo.Set( pMyCopy) ;
      }
     // se necessario e invertito oppure step successivo annullo parametri di attacco
      if ( bAdjustLiPerp  &&  ( bInvert  ||  j == 2)) {
         m_Params.m_dLiPerp = 0. ;
         m_Params.m_dLiTang = 0. ;
      }
     // se necessario e non invertito oppure step successivo annullo parametri di uscita
      if ( bAdjustLoPerp  &&  ( ! bInvert  ||  j == 2)) {
         m_Params.m_dLoPerp = 0. ;
         m_Params.m_dLoTang = 0. ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = pMyCompo->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCurve = pMyCompo->GetCurve( i) ;
        // se prima entità, se primo step approccio e sempre affondo
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart = ( ! bInvert ? m_vtStartDir : -m_vtEndDir) ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( j == 1) {
               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = dElev ;
            }
            else
               dStElev = dStep - GetLeadInOutToler() - 10 * EPS_SMALL ;
          // determino inizio attacco
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            double dCalcStElev = dStElev ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bInvert, pMyCompo, ptP1, vtDir1))
               return false ;
           // determino se l'inizio dell'attacco è fuori dal grezzo
            Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bInvert, true) ;
            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
           // determino se l'inizio dell'attacco è sopra il grezzo
            bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
           // imposto versore correzione e ausiliario sul punto di partenza
            CalcAndSetCorrAuxDir( pMyCompo, i, bInvert, true) ;
           // se primo step
            if ( j == 1) {
              // verifico di entrare in aria
               if ( ! bOutStart) {
                  m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                  return false ;
               }
              // eseguo affondo
               SetFlag( 0) ;
               if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                  return false ;
            }
           // altrimenti, affondo in feed opportuna
            else {
               bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
               SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
               if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                  return false ;
            }
           // aggiungo attacco
            bool bTang = (( ! bInvert  &&  m_Params.m_dLiTang > EPS_SMALL)  ||  ( bInvert  &&  m_Params.m_dLoTang > EPS_SMALL)) ;
            SetFeed( bTang ? GetStartFeed() : GetTipFeed()) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bInvert, pMyCompo, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
               return false ;
            }
         }
        // imposto versore correzione e ausiliario sul punto di arrivo
         CalcAndSetCorrAuxDir( pMyCompo, i + 1, bInvert, true) ;
        // elaborazioni sulla curva corrente
         if ( pCurve->GetType() == CRV_LINE) {
            const 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) {
            const 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à, uscita e se ultimo step retrazione
         if ( i == nMaxInd) {
           // se ultima passata, ripristino parametri originali di attacco/uscita
            if ( j == nStep)
               LioStatus.Restore() ;
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd = ( ! bInvert ? m_vtEndDir : -m_vtStartDir) ;
           // elevazione sul punto finale
            double dEndElev ;
            if ( j == nStep) {
               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
            }
            else
               dEndElev = - GetLeadInOutToler() ;
           // aggiungo uscita
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pMyCompo, bSplitArcs, ptP1, vtDir1)) {
               m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
               return false ;
            }
           // imposto flag fine passata sull'ultima entità emessa
            if ( ! SetFlagOnLastMove( 301))
               return false ;
           // per lame retrazione non è necessaria
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                              double dDepth, double dElev, double dOkStep, bool bSplitArcs)
{
  // recupero distanze di sicurezza
   double dSafeZ = GetSafeZ() ;

  // recupero eventuale superficie trimesh chiusa per trim/extend
   int nTriExtCstm = GDB_ID_NULL ;
   int nTesId ;
   if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
      const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
      if ( pTes != nullptr  &&  pTes->IsClosed())
         nTriExtCstm = nTesId ;
   }

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

  // gestione parametri di attacco/uscita (con backup per ripristino all'uscita)
   LeadIOStatus LioStatus( this) ;
   bool bAdjustLiPerp = ( m_Params.m_dLiPerp > 10 * EPS_SMALL) ;
   if ( bAdjustLiPerp) {
      double dNewLiPerp = max( 0., m_Params.m_dLiPerp - ( nStep - 1) * dStep) ;
      m_Params.m_dLiTang *= dNewLiPerp / m_Params.m_dLiPerp ;
      m_Params.m_dLiPerp = dNewLiPerp ;
   }
   bool bAdjustLoPerp = ( m_Params.m_dLoPerp > 10 * EPS_SMALL) ;
   if ( bAdjustLoPerp) {
      m_Params.m_dLoTang = 0 ;
      m_Params.m_dLoPerp = 0. ;
   }

  // ciclo su step più ritorni (quelli pari sono i ritorni)
   for ( int k = 1 ; k <= 2 * nStep - 1 ; ++ k) {
     // indice step
      int j = ( k + 1) / 2 ;
     // flag ritorno
      bool bReturn = ( ( k % 2) == 0) ;
     // copio la curva
      PtrOwner<ICurveComposite> pMyCompo( pCompo->Clone()) ;
      if ( IsNull( pMyCompo))
         return false ;
     // eseguo offset ed eventuale inversione per ritorno
      double dDelta = ( bReturn ? min( dStep, 5.) : 0) ;
      double dSignOffs = ( dElev - j * dStep + dDelta) * ( m_Params.m_nWorkSide == MILL_WS_LEFT ? - 1 : 1) ;
      if ( ! CalcOffset( pMyCompo, dSignOffs))
         return false ;
      if ( bReturn)
         pMyCompo->Invert() ;
     // eventuale trim/extend con la superficie indicata
      if ( nTriExtCstm != GDB_ID_NULL) {
        // trim con ripristino dell'originale in caso di errore
         PtrOwner<ICurveComposite> pMyCopy( pMyCompo->Clone()) ;
         if ( ! TrimExtendCurveToClosedStm( pMyCompo, nTriExtCstm, bReturn))
            pMyCompo.Set( pMyCopy) ;
      }
     // dopo primo step annullo parametro di attacco
      if ( k > 1  &&  bAdjustLiPerp) {
         m_Params.m_dLiPerp = 0. ;
         m_Params.m_dLiTang = 0. ;
      }
     // ciclo sulle curve elementari
      int nMaxInd = pMyCompo->GetCurveCount() - 1 ;
      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
        // curva corrente
         const ICurve* pCurve = pMyCompo->GetCurve( i) ;
        // se prima entità, se primo step approccio e sempre affondo
         if ( i == 0) {
           // dati inizio entità
            Point3d ptStart ;
            pCurve->GetStartPoint( ptStart) ;
            Vector3d vtStart = ( ! bReturn ? m_vtStartDir : -m_vtEndDir) ;
           // determino elevazione su inizio attacco
            double dStElev ;
            if ( k == 1) {
               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                  dStElev = dElev ;
            }
            else
               dStElev = dStep - GetLeadInOutToler() - 10 * EPS_SMALL ;
          // determino inizio attacco
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            double dCalcStElev = dStElev ;
            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, dCalcStElev, bReturn, pMyCompo, ptP1, vtDir1))
               return false ;
           // determino se l'inizio dell'attacco è fuori dal grezzo
            Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bReturn, true) ;
            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
           // determino se l'inizio dell'attacco è sopra il grezzo
            bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
           // imposto versore correzione e ausiliario sul punto di partenza
            CalcAndSetCorrAuxDir( pMyCompo, i, bReturn, true) ;
           // se primo step
            if ( k == 1) {
              // verifico di entrare in aria
               if ( ! bOutStart) {
                  m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                  return false ;
               }
              // eseguo affondo
               SetFlag( 0) ;
               if ( AddRapidStart( ptP1) == GDB_ID_NULL)
                  return false ;
            }
           // altrimenti, affondo ( o retrazione se Return) in feed opportuna
            else {
               bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
               SetFeed( bReturn ? GetEndFeed() : ( bStartFeed ? GetStartFeed() : GetTipFeed())) ;
               if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                  return false ;
            }
           // aggiungo attacco
            bool bTang = (( ! bReturn  &&  m_Params.m_dLiTang > EPS_SMALL)  ||  ( bReturn  &&  m_Params.m_dLoTang > EPS_SMALL)) ;
            SetFeed( bReturn ? GetEndFeed() : ( bTang ? GetStartFeed() : GetTipFeed())) ;
            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, dCalcStElev, bReturn, pMyCompo, bSplitArcs)) {
               m_pMchMgr->SetLastError( 2310, "Error in Milling : LeadIn not computable") ;
               return false ;
            }
         }
        // imposto versore correzione e ausiliario sul punto di arrivo
         CalcAndSetCorrAuxDir( pMyCompo, i + 1, bReturn, true) ;
        // se Retrazione e ultima entità, dichiaro fine passata
         if ( bReturn  &&  i == nMaxInd)
            SetFlag( 301) ;
        // elaborazioni sulla curva corrente
         if ( pCurve->GetType() == CRV_LINE) {
            const ICurveLine* pLine = GetCurveLine( pCurve) ;
            Point3d ptP3 = pLine->GetEnd() ;
            SetFeed( bReturn ? GetEndFeed() : GetFeed()) ;
            if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL) {
               SetFlag( 0) ;
               return false ;
            }
         }
         else if ( pCurve->GetType() == CRV_ARC) {
            const ICurveArc* pArc = GetCurveArc( pCurve) ;
            Point3d ptCen = pArc->GetCenter() ;
            double dAngCen = pArc->GetAngCenter() ;
            Vector3d vtN = pArc->GetNormVersor() ;
            Point3d ptP3 ;
            pArc->GetEndPoint( ptP3) ;
            SetFeed( bReturn ? GetEndFeed() : GetFeed()) ;
            if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL) {
               SetFlag( 0) ;
               return false ;
            }
         }
         SetFlag( 0) ;
        // se ultima entità, uscita e se ultimo step retrazione
         if ( i == nMaxInd) {
           // se ultima passata, ripristino parametri originali di attacco/uscita
            if ( j == nStep)
               LioStatus.Restore() ;
           // dati fine entità
            Point3d ptEnd ;
            pCurve->GetEndPoint( ptEnd) ;
            Vector3d vtEnd = ( ! bReturn ? m_vtEndDir : -m_vtStartDir) ;
           // elevazione sul punto finale
            double dEndElev ;
            if ( j == nStep) {
               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                  dEndElev = dElev ;
            }
            else
               dEndElev = - GetLeadInOutToler() ;
           // aggiungo uscita
            Point3d ptP1 ;
            Vector3d vtDir1 ;
            SetFeed( GetEndFeed()) ;
            if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bReturn, pMyCompo, bSplitArcs, ptP1, vtDir1)) {
               m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
               return false ;
            }
           // se non è return, imposto flag fine passata sull'ultima entità emessa
            if ( ! bReturn) {
               if ( ! SetFlagOnLastMove( 301))
                  return false ;
            }
           // per lame retrazione non è necessaria
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                      double dElev, double dAppr, bool bOutStart, bool bAboveStart, bool bFirst, bool bSplitArcs)
{
   SetFlag( 1) ;
  // se con aggregato da sotto o equivalente (rinvio a 90 gradi su testa 5 assi)
   bool bBottomStart = 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 ;
      bBottomStart = ( dDistBottom < - 10 * EPS_SMALL) ;
     // aggiuntivo in Z
      double dAggZ = ( bBottomStart ? 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 ( AddRapidStartOrMove( ptP00, bFirst, bSplitArcs, 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 ( AddRapidStartOrMove( ptP0, bFirst, bSplitArcs, 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 ( AddRapidStartOrMove( ptP0, bFirst, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
            return false ;
         SetFlag( 0) ;
      }
      bFirst = false ;
   }
  // se testa da sopra senza aggregato da sotto e non con tavola basculante, approccio mai da Z negativo
  // oppure testa da sotto, approccio mai da Z positivo 
   Vector3d vtAppr = vtTool ;
   if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < - EPS_SMALL)  ||
        ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
      vtAppr.z = 0 ;
      vtAppr.Normalize() ;
   }
  // se non sono già sopra il pezzo e sopra attacco c'è spazio per sicurezza o approccio
   double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
   double dElevZ = vtAppr.z * dElev ;
   if ( ! bAboveStart  &&  ! bBottomStart  &&  dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
      Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ;
     // se distanza di sicurezza minore di distanza di inizio
      if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
        // 1 -> punto sopra inizio
         if ( AddRapidStartOrMove( ptP1, bFirst, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
      else {
        // 1a -> punto molto sopra inizio
         Point3d ptP1a = ptP1 + vtAppr * ( dSafeDist - dAppr) ;
         if ( AddRapidStartOrMove( ptP1a, bFirst, 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  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
      SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
         return false ;
   }
  // sono sopra il pezzo ma non abbastanza
   else if ( bAboveStart  &&  ! m_bTiltingTab  &&  ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
     // 1b -> punto appena sopra inizio (in Z globale)
      Point3d ptP1b = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
      if ( AddRapidStartOrMove( ptP1b, bFirst, bSplitArcs) == GDB_ID_NULL)
         return false ;
     // affondo al punto iniziale
      SetFlag( 0) ;
      bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
      SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
      if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
         return false ;
   }
  // altrimenti
   else {
     // affondo diretto al punto iniziale
      if ( AddRapidStartOrMove( ptP, bFirst, bSplitArcs) == GDB_ID_NULL)
         return false ;
      SetFlag( 0) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool,
                                  double dSafeZ, double dSawStElev, double dStElev, double dAppr,
                                  bool bFirst, bool bSplitArcs, bool bAddInsert)
{
  // per approccio orizzontale vtAppr deve essere già stato sistemato dal chiamante
   SetFlag( 1) ;
  // 1a -> punto fuori inizio
   Point3d ptP1a = ptP + vtAppr * ( dSawStElev + max( dAppr, dSafeZ)) ;
   bool bOutStart = true ;
  // se necessario ulteriore approccio
   if ( ! m_bTiltingTab) {
      Vector3d vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
      if ( vtMove.Normalize()) {
         if ( m_bAboveHead  &&  vtAppr.z < LIM_DOWN_APPRZ) {
           // deve essere inizializzata a zero
            double dExtraElev = 0 ;
            if ( GetAhPointUnderRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2,
                                     GetRadiusForStartEndElevation( false),
                                     m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
               Point3d ptP1e = ptP1a + vtMove * ( dExtraElev + dSafeZ) ;
               if ( bAddInsert  &&  ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR)) {
                  Point3d ptInsert = ptP1e + ( dStElev + dSafeZ) * vtTool ;
                  if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
                     return false ;
                  SetFlag( 0) ;
                  if ( AddRapidMove( ptP1e, bSplitArcs) == GDB_ID_NULL)
                     return false ;
               }
               else {
                  if ( AddRapidStartOrMove( ptP1e, bFirst, bSplitArcs) == GDB_ID_NULL)
                     return false ;
                  SetFlag( 0) ;
               }
               bOutStart = false ;
            }
         }
         else if ( ! m_bAboveHead  &&  vtAppr.z > -LIM_DOWN_APPRZ) {
           // deve essere inizializzata a zero
            double dExtraElev = 0 ;
            if ( GetUhPointAboveRaw( ptP1a, vtTool, m_TParams.m_dTDiam / 2,
                                     GetRadiusForStartEndElevation( false),
                                     m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
               Point3d ptP1e = ptP1a + vtMove * ( dExtraElev + dSafeZ) ;
               if ( bAddInsert  &&  ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR)) {
                  Point3d ptInsert = ptP1e + ( dStElev + dSafeZ) * vtTool ;
                  if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
                     return false ;
                  SetFlag( 0) ;
                  if ( AddRapidMove( ptP1e, bSplitArcs) == GDB_ID_NULL)
                     return false ;
               }
               else {
                  if ( AddRapidStartOrMove( ptP1e, bFirst, bSplitArcs) == GDB_ID_NULL)
                     return false ;
                  SetFlag( 0) ;
               }
               bOutStart = false ;
            }
         }
      }
   }
  // punto fuori inizio
   if ( bOutStart) {
      if ( bAddInsert  &&  ! AreSameVectorEpsilon( vtAppr, vtTool, LIM_SIN_DIFF_DIR)) {
         Point3d ptInsert = ptP1a + ( dStElev + dSafeZ) * vtTool ;
         if ( AddRapidStartOrMove( ptInsert, bFirst, bSplitArcs) == GDB_ID_NULL)
            return false ;
         SetFlag( 0) ;
         if ( AddRapidMove( ptP1a, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
      else {
         if ( AddRapidStartOrMove( ptP1a, bFirst, bSplitArcs) == GDB_ID_NULL)
            return false ;
         SetFlag( 0) ;
      }
   }
   else {
      if ( AddRapidMove( ptP1a, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
  // 1b -> punto appena sopra inizio (se necessario)
   if ( dSafeZ > dAppr + 10 * EPS_SMALL  &&  dSawStElev + dAppr > 10 * EPS_SMALL) {
      Point3d ptP1b = ptP + vtAppr * ( dSawStElev + dAppr) ;
      if ( AddRapidMove( ptP1b, bSplitArcs) == GDB_ID_NULL)
         return false ;
   }
  // affondo al punto iniziale in feed
   SetFeed( GetStartFeed()) ;
   if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
      return false ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddDirectApproach( const Point3d& ptP, bool bSplitArcs)
{
  // affondo diretto al punto iniziale
   SetFlag( 0) ;
   SetFeed( GetStartFeed()) ;
   if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                     double dElev, double dAppr, bool bAboveEnd, bool bSplitArcs)
{
  // se testa da sopra senza aggregato da sotto, retrazione mai da Z negativo
   Vector3d vtAppr = vtTool ;
   if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < - EPS_SMALL)  ||
        ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
      vtAppr.z = 0 ;
      vtAppr.Normalize() ;
   }
  // 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 (se negativa il punto è fuori dal grezzo)
      if ( ! GetAggrBottDistanceFromRawSide( m_nPhase, ptP, m_vtAggrBottom, ( m_AggrBottom.dEncH + dSafeZ), dDistBottom))
         dDistBottom = 0 ;
      bBottomOutStart = ( dDistBottom < - 10 * EPS_SMALL) ;
   }
  // se non sono già sopra il pezzo e sopra uscita c'è spazio per sicurezza o approccio
   double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
   double dElevZ = vtAppr.z * dElev ;
   if ( ! bAboveEnd  &&  ! 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 + vtAppr * ( 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 + vtAppr * ( 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 + vtAppr * ( dSafeDist - dAppr) ;
         if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
   }
  // sono sopra il pezzo ma non abbastanza
   else if ( bAboveEnd  &&  ! m_bTiltingTab  &&  ( min( dElevZ, 0.) + dAppr) > 10 * EPS_SMALL) {
      if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
        // 4 -> movimento di risalita sopra il punto finale
         SetFeed( GetEndFeed()) ;
         Point3d ptP4 = ptP + Z_AX * ( min( dElevZ, 0.) + 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 + Z_AX * ( min( dElevZ, 0.) + 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 + Z_AX * ( dSafeDist - dAppr) ;
         if ( AddRapidMove( ptP4b, bSplitArcs) == GDB_ID_NULL)
            return false ;
      }
   }
  // se con aggregato da sotto
   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 rinvio da sotto che 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
Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool,
                                 double dSafeZ, double dSawEndElev, double dEndElev, double dAppr, bool bAddExtract)
{
  // per retrazione orizzontale vtAppr deve essere già stato sistemato dal chiamante
   Point3d ptP4 = ptP ;
  // se sopra uscita c'è spazio per approccio
   if ( dSawEndElev + dAppr > 10 * EPS_SMALL) {
      SetFeed( GetEndFeed()) ;
      ptP4 = ptP + vtRetr * ( dSawEndElev + dAppr) ;
      if ( AddLinearMove( ptP4, MCH_CL_SAFEOUT) == GDB_ID_NULL)
         return false ;
   }
  // se sopra uscita c'è spazio per sicurezza
   if ( dSafeZ - dAppr > 10 * EPS_SMALL) {
      ptP4 += vtRetr * ( dSafeZ - dAppr) ;
      if ( AddRapidMove( ptP4) == GDB_ID_NULL)
         return false ;
   }

  // se necessaria ulteriore uscita
   Vector3d vtMove ;
   double dMove = 0 ;
   if ( ! m_bTiltingTab) {
      vtMove = Vector3d( vtTool.x, vtTool.y, 0) ;
      if ( vtMove.Normalize()) {
         if ( m_bAboveHead  &&  vtRetr.z < LIM_DOWN_APPRZ) {
           // deve essere inizializzata a zero
            double dExtraElev = 0 ;
            if ( GetAhPointUnderRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2,
                                     GetRadiusForStartEndElevation( false),
                                     m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
               dMove = dExtraElev + dSafeZ ;
               Point3d ptP4b = ptP4 + vtMove * dMove ;
               if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
                  return false ;
            }
         }
         else if ( ! m_bAboveHead  &&  vtRetr.z > -LIM_DOWN_APPRZ) {
           // deve essere inizializzata a zero
            double dExtraElev = 0 ;
            if ( GetUhPointAboveRaw( ptP4, vtTool, m_TParams.m_dTDiam / 2,
                                     GetRadiusForStartEndElevation( false),
                                     m_TParams.m_dLen, true, dSafeZ, vtMove, dExtraElev)) {
               dMove = dExtraElev + dSafeZ ;
               Point3d ptP4b = ptP4 + vtMove * dMove ;
               if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
                  return false ;
            }
         }
      }
   }

   if ( bAddExtract  &&  ! AreSameVectorEpsilon( vtRetr, vtTool, LIM_SIN_DIFF_DIR)  &&
        ( ! AreSameVectorEpsilon( vtMove, vtTool, LIM_SIN_DIFF_DIR)  ||  dEndElev + dSafeZ > dMove + 10 * EPS_SMALL)) {
      Point3d ptCurr ;
      if ( ! GetCurrPos( ptCurr))
         return false ;
      Point3d ptExtract = ptCurr + ( dEndElev + dSafeZ - dMove) * vtTool ;
      if ( AddRapidMove( ptExtract) == GDB_ID_NULL)
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
int
Milling::GetLeadInType( void) const
{
   if ( abs( m_Params.m_dLiTang) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        abs( m_Params.m_dLiPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1))
      return MILL_LI_NONE ;
   if ( m_Params.m_nLeadInType == MILL_LI_GLIDE  &&  m_Params.m_dLiElev < 10 * EPS_SMALL)
      return MILL_LI_NONE ;
   if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX  ||  m_Params.m_nLeadInType == MILL_LI_ZIGZAG)  &&
         ( m_Params.m_dLiTang < min( 0.1 * m_TParams.m_dDiam, 1.0)  ||  m_Params.m_dLiElev < 10 * EPS_SMALL))
      return MILL_LI_NONE ;
   if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX  ||  m_Params.m_nLeadInType == MILL_LI_ZIGZAG)  &&
        m_bStepOn  &&  m_Params.m_nStepType == MILL_ST_SPIRAL)
      return MILL_LI_NONE ;
   if ( ( m_Params.m_nLeadInType == MILL_LI_HELIX  ||  m_Params.m_nLeadInType == MILL_LI_ZIGZAG)  &&
        ( m_TParams.m_nType & TF_SAWBLADE) != 0)
      return MILL_LI_LINEAR ;
   return m_Params.m_nLeadInType ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool,
                          double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1, Vector3d& vtDir1) const
{
  // Assegno tipo e parametri
   int nType = GetLeadInType() ;
   double dTang = m_Params.m_dLiTang ;
   double dPerp = m_Params.m_dLiPerp ;
   double dElev = m_Params.m_dLiElev ;
   if ( m_TParams.m_nType != TT_MILL_POLISHING)
      dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
  // se step invertito
   if ( bInvert) {
     // va aggiustato se non zigzag o spirale
      if ( nType != MILL_LI_ZIGZAG  &&  nType != MILL_LI_HELIX) {
         switch ( GetLeadOutType()) {
         case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
         case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ;
         case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
         case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
         case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
         default : nType = MILL_LI_NONE ; break ;
         }
         if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
            dTang = m_Params.m_dLoTang ;
            dPerp = m_Params.m_dLoPerp ;
            dElev = m_Params.m_dLoElev ;
            if ( m_TParams.m_nType != TT_MILL_POLISHING)
               dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
         }
      }
   }
  // senso di rotazione da dir tg a dir esterna
   bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
                   ( bInvert  &&  m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
  // verifico di poter fare l'ingresso a inseguimento
   if ( nType == MILL_LI_GLIDE  &&  ! pCompo->IsClosed()  &&  m_dAddedOverlap < EPS_SMALL)
      nType = MILL_LI_NONE ;
  // Calcolo punto iniziale
   switch ( nType) {
   case MILL_LI_NONE :
      ptP1 = ptStart ;
      vtDir1 = -vtStart ;
      return true ;
   case MILL_LI_LINEAR : {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
         ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
         vtDir1 = ptP1 - ptStart ;
         if ( ! vtDir1.Normalize())
            return false ;
         bool bOk = true ;
        // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
         if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
            vtDir1 = OrthoCompo( vtDir1, vtTool) ;
            bOk = bOk && vtDir1.Normalize() ;
            vtDir1.Rotate( vtRot, 0, ( bCcwRot ? -1 : 1)) ;
            ptP1 += vtDir1 * m_Params.m_dLiCompLen ;
         }
         return bOk ;
      } 
   case MILL_LI_TG_PERP : {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
         ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
         vtDir1 = ptP1 - ptStart ;
         return vtDir1.Normalize() ;
      }
   case MILL_LI_TANGENT : {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : -1)) ;
         ptP1 = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
         vtDir1 = ptP1 - ptStart ;
         if ( ! vtDir1.Normalize())
            return false ;
         bool bOk = true ;
        // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
         if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
            PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtTool)) ;
            bOk = bOk && ! IsNull( pCrv) && pCrv->GetEndDir( vtDir1) ;
            vtDir1 = OrthoCompo( vtDir1, vtTool) ;
            bOk = bOk && vtDir1.Normalize() ;
            vtDir1.Rotate( vtRot, 0, ( bCcwRot ? -1 : 1)) ;
            ptP1 += vtDir1 * m_Params.m_dLiCompLen ;
         }
         return bOk ;
      }
   case MILL_LI_GLIDE :
      {
         if ( ! bInvert) {
            double dLen, dU ;
            if ( ! pCompo->GetLength( dLen)  ||  ! pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)  ||
                 ! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
               if ( ! pCompo->GetStartPoint( ptP1))
                  return false ;
            }
         }
         else {
            double dU ;
            if ( ! pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)  ||
                 ! pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP1)) {
               if ( ! pCompo->GetEndPoint( ptP1))
                  return false ;
            }
         }
         ptP1 += vtTool * ( vtTool * ( ptStart - ptP1)) + vtTool * dElev ;
         vtDir1 = ptP1 - ptStart ;
         return vtDir1.Normalize() ;
      }
   case MILL_LI_ZIGZAG :
      ptP1 = ptStart ;
      vtDir1 = -vtStart ;
      return true ;
   case MILL_LI_HELIX :
      ptP1 = ptStart ;
      vtDir1 = -vtStart ;
      return true ;
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
                    const Vector3d& vtTool, double dStElev, bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs)
{
  // Assegno il tipo
   int nType = GetLeadInType() ;
   double dTang = m_Params.m_dLiTang ;
   double dPerp = m_Params.m_dLiPerp ;
   double dElev = m_Params.m_dLiElev ;
   if ( m_TParams.m_nType != TT_MILL_POLISHING)
      dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
  // se step invertito
   if ( bInvert) {
     // va aggiustato se non zigzag o spirale
      if ( nType != MILL_LI_ZIGZAG  &&  nType != MILL_LI_HELIX) {
         switch ( GetLeadOutType()) {
         case MILL_LO_LINEAR : nType = MILL_LI_LINEAR ; break ;
         case MILL_LO_PERP_TG : nType = MILL_LI_TG_PERP ; break ;
         case MILL_LO_TANGENT : nType = MILL_LI_TANGENT ; break ;
         case MILL_LO_GLIDE : nType = MILL_LI_GLIDE ; break ;
         case MILL_LO_AS_LI : /* resta inalterato */ ; break ;
         default : nType = MILL_LI_NONE ; break ;
         }
         if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
            dTang = m_Params.m_dLoTang ;
            dPerp = m_Params.m_dLoPerp ;
            dElev = m_Params.m_dLoElev ;
            if ( m_TParams.m_nType != TT_MILL_POLISHING)
               dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
         }
      }
   }
  // senso di rotazione da dir tg a dir esterna
   bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
                   ( bInvert  &&  m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
  // verifico di poter fare l'ingresso a inseguimento
   if ( nType == MILL_LI_GLIDE  &&  ! pCompo->IsClosed()  &&  m_dAddedOverlap < EPS_SMALL)
      nType = MILL_LI_NONE ;
  // Eseguo a seconda del tipo
   switch ( nType) {
   case MILL_LI_NONE :
      return true ;
   case MILL_LI_LINEAR :
      // se c'è elevazione di attacco e utensile flottante faccio precedere solo movimento in elevazione
      if ( m_bTHoldFloating  &&  dElev > 10 * EPS_SMALL) {
         Point3d ptMid = ptP1 - dElev * vtTool ;
         if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
            return false ;
         dElev = 0 ;
      }
     // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
      if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         Point3d ptMid = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
         if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
            return false ;
      }
      return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
   case MILL_LI_TG_PERP :
      {
         Vector3d vtPerp = vtStart ;
         Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         Point3d ptMid = ptStart + vtPerp * dPerp ;
         return ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL  &&
                  AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
   case MILL_LI_TANGENT :
      {
         Point3d ptMid = ptP1 ;
        // se c'è elevazione di attacco e utensile flottante faccio precedere solo movimento in elevazione
         if ( m_bTHoldFloating  &&  dElev > 10 * EPS_SMALL) {
            ptMid += - dElev * vtTool ;
            if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
            dElev = 0 ;
         }
        // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
         if ( m_Params.m_dLiCompLen > 10 * EPS_SMALL) {
            Vector3d vtPerp = vtStart ;
            Vector3d vtRot = OrthoCompo( vtTool, vtStart) ;
            vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
            ptMid = ptStart - vtStart * dTang + vtPerp * dPerp + vtTool * dElev ;
            if ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
         }
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptMid, - vtStart, vtTool)) ;
         if ( IsNull( pCrv))
            return false ;
         pCrv->Invert() ;
         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
   case MILL_LI_GLIDE :
      {
        // recupero la parte richiesta della curva
         PtrOwner<ICurveComposite> pCrv ;
         if ( ! bInvert) {
            double dLen, dU ;
            if ( pCompo->GetLength( dLen)  &&  pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
               double dParS, dParE ;
               pCompo->GetDomain( dParS, dParE) ;
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            if ( m_dAddedOverlap > EPS_SMALL) {
               pCrv->Invert() ;
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
               pCrv->Invert() ;
            }
         }
         else {
            double dU ;
            if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            if ( m_dAddedOverlap > EPS_SMALL)
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
            pCrv->Invert() ;
         }
         pCrv->SetExtrusion( vtTool) ;
        // 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) * vtTool ;
         double dNfin = ( ptStart - ORIG) * vtTool ;
         AdjustCurveSlope( pCrv, dNini, dNfin) ;
        // emetto (con eventuale spezzatura)
         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
   case MILL_LI_ZIGZAG :
      {
        // recupero la parte richiesta della curva
         PtrOwner<ICurveComposite> pCrv ;
         if ( ! bInvert) {
            double dU ;
            if ( pCompo->GetParamAtLength( dTang, dU)) {
               double dParS, dParE ;
               pCompo->GetDomain( dParS, dParE) ;
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dParS, dU))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
         }
         else {
            double dLen, dU ;
            if ( pCompo->GetLength( dLen)  &&  pCompo->GetParamAtLength( dLen - dTang, dU)) {
               double dParS, dParE ;
               pCompo->GetDomain( dParS, dParE) ;
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            pCrv->Invert() ;
         }
         pCrv->SetExtrusion( vtTool) ;
        // la porto alla giusta quota
         Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
         Vector3d vtMove = ptStart - ptIni ;
         pCrv->Translate( vtMove) ;
        // la ripeto a zigzag
         double dDeltaN = ( ptStart - ptP1) * vtTool ;
         int nStep = int( ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL))) ;
         double dStep = - dDeltaN / nStep ;
         for ( int i = 1 ; i <= nStep ; ++ i) {
           // calcolo quote per pendenza
            double dNini = ( ptP1 - ORIG) * vtTool - ( i - 1) * dStep ;
            double dNmid = dNini - 0.5 * dStep ;
            double dNfin = dNmid - 0.5 * dStep ;
           // copio per zig
            PtrOwner<ICurveComposite> pCopy1( pCrv->Clone()) ;
           // assegno la corretta pendenza
            AdjustCurveSlope( pCopy1, dNini, dNmid) ;
           // emetto
            if ( AddCurveMove( pCopy1, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
           // copio per zag
            PtrOwner<ICurveComposite> pCopy2( pCrv->Clone()) ;
            pCopy2->Invert() ;
           // assegno la corretta pendenza
            AdjustCurveSlope( pCopy2, dNmid, dNfin) ;
           // emetto
            if ( AddCurveMove( pCopy2, bSplitArcs, MCH_CL_LEADIN) == GDB_ID_NULL)
               return false ;
         }
         return true ;
      }
   case MILL_LI_HELIX :
      {
         bool bAtLeft = ( bInvert != ( m_Params.m_nWorkSide != MILL_WS_RIGHT)) ;
        // vettore dal punto al centro elica
         Vector3d vtCen = vtStart ;
         vtCen.Rotate( vtTool, 0, ( bAtLeft ? 1 : - 1)) ;
        // dati dell'elica
         double dRad = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
         Point3d ptCen = ptP1 + vtCen * dRad ;
         double dDeltaN = ( ptStart - ptP1) * vtTool ;
         double dAngCen = ceil( - dDeltaN / ( m_Params.m_dLiElev + 10 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
        // creo l'elica
         PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
         if ( IsNull( pArc)  ||  ! pArc->Set( ptCen, vtTool, dRad, - vtCen, dAngCen, dDeltaN))
            return false ;
        // emetto l'elica (con eventuale spezzatura)
         return ( AddCurveMove( pArc, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
      }
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
int
Milling::GetLeadOutType( void) const
{
   if ( abs( m_Params.m_dLoTang) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        abs( m_Params.m_dLoPerp) < min( 0.1 * m_TParams.m_dDiam, 0.1)  &&
        m_Params.m_nLeadOutType  != MILL_LO_AS_LI)
      return MILL_LO_NONE ;
   if ( m_Params.m_nLeadOutType == MILL_LO_GLIDE  &&  m_Params.m_dLoElev < 10 * EPS_SMALL)
      return MILL_LO_NONE ;
   return m_Params.m_nLeadOutType ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool,
                         double dEndElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1) const
{
  // assegno i parametri
   int nType = GetLeadOutType() ;
   double dTang = m_Params.m_dLoTang ;
   double dPerp = m_Params.m_dLoPerp ;
   double dElev = m_Params.m_dLoElev ;
   if ( m_TParams.m_nType != TT_MILL_POLISHING)
      dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
  // se uscita come ingresso o step invertito
   if ( nType == MILL_LO_AS_LI  ||  bInvert) {
      int nLiType = GetLeadInType() ;
      switch ( nLiType) {
      case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
      case MILL_LI_TG_PERP : nType = MILL_LO_PERP_TG ; break ;
      case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
      case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
      case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ;
      case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ;
      default : nType = MILL_LO_NONE ; break ;
      }
      dTang = m_Params.m_dLiTang ;
      dPerp = m_Params.m_dLiPerp ;
      if ( nLiType == MILL_LI_HELIX) {
         dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
         dPerp = dTang ;
      }
     dElev = m_Params.m_dLiElev ;
     if ( m_TParams.m_nType != TT_MILL_POLISHING)
        dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
   }
  // senso di rotazione da dir tg a dir esterna
   bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
                   ( bInvert &&  m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
  // verifico di poter fare l'uscita a inseguimento
   if ( nType == MILL_LO_GLIDE  &&  ! pCompo->IsClosed()  &&  m_dAddedOverlap < EPS_SMALL)
      nType = MILL_LO_NONE ;
  // eseguo a seconda del tipo
   switch ( nType) {
   case MILL_LO_NONE :
      ptP1 = ptEnd ;
      return true ;
   case MILL_LO_LINEAR :
      {
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
         if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
            Vector3d vtPerp2 = vtEnd * dTang + vtPerp * dPerp ;
            if ( vtPerp2.Normalize()) {
               vtPerp2.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
               ptP1 += vtPerp2 * m_Params.m_dLoCompLen ;
            }
         }
         return true ;
      }
   case MILL_LO_PERP_TG :
      {
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         Point3d ptMid = ptEnd + vtPerp * dPerp ;
         ptP1 = ptMid + vtEnd * dTang + vtTool * dElev ;
         return true ;
      }
   case MILL_LO_TANGENT :
      {
        // calcolo punto finale dell'uscita
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
         if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
            Vector3d vtPerp2 = vtEnd * dTang + vtPerp * dPerp ;
            if ( vtPerp2.Normalize()) {
               vtPerp2.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
               ptP1 += vtPerp2 * m_Params.m_dLoCompLen ;
            }
         }
         return true ;
      }
   case MILL_LO_GLIDE :
      {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         if ( ! bInvert) {
            double dU ;
            if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            if ( m_dAddedOverlap > EPS_SMALL)
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
         }
         else {
            double dLen, dU ;
            if ( pCompo->GetLength( dLen)  &&  pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
               double dParS, dParE ;
               pCompo->GetDomain( dParS, dParE) ;
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            pCrv->Invert() ;
            if ( m_dAddedOverlap > EPS_SMALL)
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
         }
         pCrv->SetExtrusion( vtTool) ;
        // la porto alla giusta quota
         Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
         Vector3d vtMove = ptEnd - ptIni ;
         pCrv->Translate( vtMove) ;
        // assegno la corretta pendenza
         double dNini = ( ptEnd - ORIG) * vtTool ;
         AdjustCurveSlope( pCrv, dNini, dNini + dElev) ;
        // assegno punto finale dell'uscita
         pCrv->GetEndPoint( ptP1) ;
         return true ;
      }
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, double dEndElev,
                     bool bInvert, const ICurveComposite* pCompo, bool bSplitArcs, Point3d& ptP1, Vector3d& vtDir1)
{
  // assegno i parametri
   int nType = GetLeadOutType() ;
   double dTang = m_Params.m_dLoTang ;
   double dPerp = m_Params.m_dLoPerp ;
   double dElev = m_Params.m_dLoElev ;
   if ( m_TParams.m_nType != TT_MILL_POLISHING)
      dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
  // se uscita come ingresso o step invertito
   if ( nType == MILL_LO_AS_LI  ||  bInvert) {
      int nLiType = GetLeadInType() ;
      switch ( nLiType) {
      case MILL_LI_LINEAR : nType = MILL_LO_LINEAR ; break ;
      case MILL_LI_TG_PERP : nType = MILL_LO_PERP_TG ; break ;
      case MILL_LI_TANGENT : nType = MILL_LO_TANGENT ; break ;
      case MILL_LI_GLIDE : nType = MILL_LO_GLIDE ; break ;
      case MILL_LI_ZIGZAG : nType = MILL_LO_NONE ; break ;
      case MILL_LI_HELIX : nType = MILL_LO_NONE ; break ;
      default : nType = MILL_LO_NONE ; break ;
      }
      dTang = m_Params.m_dLiTang ;
      dPerp = m_Params.m_dLiPerp ;
      if ( nLiType == MILL_LI_HELIX) {
         dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
         dPerp = dTang ;
      }
      dElev = m_Params.m_dLiElev ;
      if ( m_TParams.m_nType != TT_MILL_POLISHING)
         dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
   }
  // senso di rotazione da dir tg a dir esterna
   bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
                   ( bInvert &&  m_Params.m_nWorkSide != MILL_WS_LEFT)) ;
  // verifico di poter fare l'uscita a inseguimento
   if ( nType == MILL_LO_GLIDE  &&  ! pCompo->IsClosed()  &&  m_dAddedOverlap < EPS_SMALL)
      nType = MILL_LO_NONE ;
  // eseguo a seconda del tipo
   switch ( nType) {
   case MILL_LO_NONE :
      ptP1 = ptEnd ;
      vtDir1 = vtEnd ;
      return true ;
   case MILL_LO_LINEAR :
      {
        // se utensile flottante, l'elevazione va tutta in un movimento finale aggiuntivo
         double dFloatElev = 0 ;
         if ( m_bTHoldFloating)
            swap( dElev, dFloatElev) ;
        // calcolo punto finale dell'uscita
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
         vtDir1 = ptP1 - ptEnd ;
         if ( ! vtDir1.Normalize())
            return false ;
        // inserisco movimento di uscita
         bool bOk = ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
        // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
         if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
            vtDir1 = OrthoCompo( vtDir1, vtTool) ;
            bOk = bOk && vtDir1.Normalize() ;
            vtDir1.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
            ptP1 += vtDir1 * m_Params.m_dLoCompLen ;
            bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
         }
        // eventuale movimento in elevazione per flottante
         if ( m_bTHoldFloating  &&  dFloatElev > 10 * EPS_SMALL) {
            ptP1 += dFloatElev * vtTool ;
            bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
         }
         return bOk ;
      }
   case MILL_LO_PERP_TG :
      {
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         Point3d ptMid = ptEnd + vtPerp * dPerp ;
         ptP1 = ptMid + vtEnd * dTang + vtTool * dElev ;
         vtDir1 = ptP1 - ptMid ; vtDir1.Normalize() ;
         return ( AddLinearMove( ptMid, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL  &&
                  AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
      }
   case MILL_LO_TANGENT :
      {
        // se utensile flottante, l'elevazione va tutta in un movimento finale aggiuntivo
         double dFloatElev = 0 ;
         if ( m_bTHoldFloating)
            swap( dElev, dFloatElev) ;
        // calcolo punto finale dell'uscita
         Vector3d vtPerp = vtEnd ;
         Vector3d vtRot = OrthoCompo( vtTool, vtEnd) ;
         vtPerp.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp + vtTool * dElev ;
         vtDir1 = ptP1 - ptEnd ;
         if ( ! vtDir1.Normalize())
            return false ;
        // inserisco movimento di uscita
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtTool)) ;
         if ( IsNull( pCrv))
            return false ;
         Vector3d vtDirF ;
         if ( ! pCrv->GetEndDir( vtDirF))
            return false ;
         bool bOk = true ;
         bOk = ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
        // eventuale movimento ortogonale (estensione di inserimento compensazione raggio utensile)
         if ( m_Params.m_dLoCompLen > 10 * EPS_SMALL) {
            vtDir1 = OrthoCompo( vtDirF, vtTool) ;
            bOk = bOk && vtDir1.Normalize() ;
            vtDir1.Rotate( vtRot, 0, ( bCcwRot ? 1 : - 1)) ;
            ptP1 += vtDir1 * m_Params.m_dLoCompLen ;
            bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
         }
        // eventuale movimento in elevazione per flottante
         if ( m_bTHoldFloating  &&  dFloatElev > 10 * EPS_SMALL) {
            ptP1 += dFloatElev * vtTool ;
            bOk = bOk && ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
         }
         return bOk ;
      }
   case MILL_LO_GLIDE :
      {
        // recupero la parte richiesta della curva di ritorno
         PtrOwner<ICurveComposite> pCrv ;
         if ( ! bInvert) {
            double dU ;
            if ( pCompo->GetParamAtLength( m_dAddedOverlap + dTang, dU)) {
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( 0, dU))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            if ( m_dAddedOverlap > EPS_SMALL)
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
         }
         else {
            double dLen, dU ;
            if ( pCompo->GetLength( dLen)  &&  pCompo->GetParamAtLength( dLen - m_dAddedOverlap - dTang, dU)) {
               double dParS, dParE ;
               pCompo->GetDomain( dParS, dParE) ;
               if ( ! pCrv.Set( ConvertCurveToComposite( pCompo->CopyParamRange( dU, dParE))))
                  return false ;
            }
            else {
               if ( ! pCrv.Set( pCompo->Clone()))
                  return false ;
            }
            pCrv->Invert() ;
            if ( m_dAddedOverlap > EPS_SMALL)
               pCrv->TrimStartAtLen( m_dAddedOverlap) ;
         }
         pCrv->SetExtrusion( vtTool) ;
        // la porto alla giusta quota
         Point3d ptIni ; pCrv->GetStartPoint( ptIni) ;
         Vector3d vtMove = ptEnd - ptIni ;
         pCrv->Translate( vtMove) ;
        // assegno la corretta pendenza
         double dNini = ( ptEnd - ORIG) * vtTool ;
         AdjustCurveSlope( pCrv, dNini, dNini + dElev) ;
        // emetto
         AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) ;
        // assegno punto e direzione finale dell'uscita
         pCrv->GetEndPoint( ptP1) ;
         pCrv->GetEndDir( vtDir1) ;
         return true ;
      }
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen)
{
  // se c'è oscillazione cerco di aggiustare le lunghezze dei Flat per finire con la stessa quota di partenza
   dRampLen = abs( m_Params.m_dOscRampLen) ;
   dFlatLen = abs( m_Params.m_dOscFlatLen) ;
   if ( bPathOscEnable) {
     // lunghezza del percorso
      double dLen ; pCrv->GetLength( dLen) ;
     // se percorso più corto di mezza oscillazione, la disabilito
      if ( dLen < 2 * dRampLen + 2 * OSC_MIN_LEN) {
         bPathOscEnable = false ;
         m_pMchMgr->SetWarning( 2361, "Warning in Milling : oscillation impossible") ;
      }
      else {
         int nOsc = max( static_cast<int>( dLen / ( 2 * dRampLen + 2 * dFlatLen)), 1) ;
         dFlatLen = ( dLen - nOsc * 2 * dRampLen) / ( 2 * nOsc) ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddOscillLine( const ICurveLine* pLine, const Vector3d& vtTool, double dRampLen, double dFlatLen)
{
  // lunghezze dei tratti di oscillazione
   dRampLen = max( dRampLen, OSC_MIN_LEN) ;
   dFlatLen = max( dFlatLen, OSC_MIN_LEN) ;
   double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ;
  // lunghezza della linea
   double dLen ; pLine->GetLength( dLen) ;
  // lunghezza corrente sulla linea
   double dCurrLen = 0 ;
  // emissione oscillazioni
   while ( dCurrLen < dLen - EPS_ZERO) {
     // lunghezza rimanente
      double dNextLen = dLen - dCurrLen ;
     // se inizio è sul primo tratto (rampa discendente)
      if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[0] ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[0] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[0] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul secondo tratto (parte piatta in basso)
      else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[1] ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[1] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[1] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul terzo tratto (rampa ascendente)
      else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[2] ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[2] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[2] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti è sul quarto tratto (parte piatta in alto)
      else {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = 0 ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[3] - m_dCurrOscillLen ;
            m_dCurrOscillLen = 0 ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
   }
   return true ;
}         

//----------------------------------------------------------------------------
bool
Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRampLen, double dFlatLen)
{
  // lunghezze dei tratti di oscillazione
   dRampLen = max( dRampLen, OSC_MIN_LEN) ;
   dFlatLen = max( dFlatLen, OSC_MIN_LEN) ;
   double vLenRef[4] = { dRampLen, dRampLen + dFlatLen, 2 * dRampLen + dFlatLen, 2 * dRampLen + 2 * dFlatLen} ;
  // parametria dell'arco
   Point3d ptCen = pArc->GetCenter() ;
   double dAngCen = pArc->GetAngCenter() ;
   Vector3d vtN = pArc->GetNormVersor() ;
   double dLen ; pArc->GetLength( dLen) ;
  // lunghezza corrente sull'arco
   double dCurrLen = 0 ;
  // emissione oscillazioni
   while ( dCurrLen < dLen - EPS_ZERO) {
     // lunghezza rimanente
      double dNextLen = dLen - dCurrLen ;
     // se inizio è sul primo tratto (rampa discendente)
      if ( m_dCurrOscillLen < vLenRef[0] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * m_dCurrOscillLen / vLenRef[0]) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[0] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[0] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[0] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul secondo tratto (parte piatta in basso)
      else if ( m_dCurrOscillLen < vLenRef[1] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[1] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[1] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[1] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 -= vtTool * abs( m_Params.m_dOscHeight) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul terzo tratto (rampa ascendente)
      else if ( m_dCurrOscillLen < vLenRef[2] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 -= vtTool * ( abs( m_Params.m_dOscHeight) * ( vLenRef[2] - m_dCurrOscillLen) / ( vLenRef[2] - vLenRef[1])) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = vLenRef[2] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[2] - m_dCurrOscillLen ;
            m_dCurrOscillLen = vLenRef[2] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti è sul quarto tratto (parte piatta in alto)
      else {
        // se fine linea è entro il tratto
         if ( m_dCurrOscillLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrOscillLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrOscillLen = 0 ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[3] - m_dCurrOscillLen ;
            m_dCurrOscillLen = 0 ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs)
{
  // se ci sono i tab cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza
   double dTabLen = m_Params.m_dTabLen + m_TParams.m_dDiam ;
   double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ;
   tdTabs.m_dRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
   tdTabs.m_dTopLen = abs( dTabLen) - 2 * tdTabs.m_dRampLen ;
   tdTabs.m_dBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
   if ( bPathTabsEnable) {
     // lunghezza del percorso
      double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
     // se percorso non permette nemmeno un tab disabilito
      if ( dLen < ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen)) {
         bPathTabsEnable = false ;
         m_pMchMgr->SetWarning( 2363, "Warning in Milling : tabs impossible") ;
      }
      else {
        // calcolo numero di tabs e distanza
         int nTabs = max( static_cast<int>( dLen / ( 2 * tdTabs.m_dRampLen + tdTabs.m_dBottomLen + tdTabs.m_dTopLen)), 0) ;
         nTabs = min( nTabs, m_Params.m_nTabMax) ;
         if ( nTabs < m_Params.m_nTabMin) {
            if ( dLen > ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen) * m_Params.m_nTabMin)
               nTabs = m_Params.m_nTabMin ;
            else
               m_pMchMgr->SetWarning( 2364, "Warning in Milling : tabs number less than minimum") ;
         }
         if ( nTabs > 0)
            tdTabs.m_dBottomLen = ( dLen - nTabs * ( 2 * tdTabs.m_dRampLen + tdTabs.m_dTopLen)) / nTabs ;
      }
   }
  // verifico che le lughezze non siano inferiori al minimo
   tdTabs.m_dRampLen = max( tdTabs.m_dRampLen, OSC_MIN_LEN) ;
   tdTabs.m_dBottomLen = max( tdTabs.m_dBottomLen, OSC_MIN_LEN) ;
   tdTabs.m_dTopLen = max( tdTabs.m_dTopLen, OSC_MIN_LEN) ;
   return true ;
}

//----------------------------------------------------------------------------
static void
PeriodicIntervalsSubract( Intervals& ivItv, double dPeriod, double dMin, double dMax)
{
   if ( dMin < - EPS_SMALL) {
      ivItv.Subtract( dPeriod + dMin, dPeriod) ;
      dMin = 0 ;
   }
   if ( dMax > dPeriod + EPS_SMALL) {
      ivItv.Subtract( dMin, dPeriod) ;
      dMax -= dPeriod ;
   }
   if ( dMin < dMax)
      ivItv.Subtract( dMin, dMax) ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcTabsPositions( const ICurveComposite* pCompo, double dDepth, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs)
{
  // reset posizioni Tabs
   vdTabs.clear() ;

  // recupero gruppo ausiliario per Tabs
   int nTabsId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_TABS) ;

  // se Tabs non abilitati, cancello gruppo ausiliario relativo ed esco
   if ( ! bPathTabsEnable) {
      m_pGeomDB->Erase( nTabsId) ;
      return true ;
   }

  // disabilito eventuale registrazione comandi EXE (riabilitazione automatica)
   CmdLogOff cmdLogOff ;

  // creo o svuoto gruppo ausiliario tabs
   if ( nTabsId == GDB_ID_NULL) {
      nTabsId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
      if ( nTabsId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nTabsId, MCH_TABS) ;
   }
  // altrimenti,  lo svuoto
   else
      m_pGeomDB->EmptyGroup( nTabsId) ;

  // lunghezza di un Tab
   double dTabLen = tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen ;

  // lunghezza del percorso
   double dLen ; pCompo->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
  // vettore estrusione del percorso
   Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
   if ( vtExtr.IsSmall())
      vtExtr = Z_AX ;

  // determinazione intervalli validi
   Intervals ivTabs ;
  // inizializzo intervallo valido (non sono ammessi tab a cavallo di inizio/fine)
   ivTabs.Set( 0, dLen - dTabLen) ;
  // elimino le zone con piccolo raggio e quelle vicine agli angoli
   const double RAD_MIN = 50 ;
   const double CORNER_RAG = 2 ;
   const double CORNER_ANG = 5 ;
   const double CORNER_DIST = 2 ;
   bool bContinue = true ;
   double dJointLen = 0 ;
   const ICurve* pCurrCrv = pCompo->GetFirstCurve() ;
   const ICurve* pNextCrv = pCompo->GetNextCurve() ;
   while ( pNextCrv != nullptr) {
     // calcolo lunghezza entità
      double dEntLen = 0 ;
      pCurrCrv->GetLength( dEntLen) ;
     // se arco, verifico se spigolo o inferiore a raggio minimo
      const ICurveArc* pArc = GetCurveArc( pCurrCrv) ;
      if ( pArc != nullptr) {
        // determino il raggio sul profilo
         bool bCCW = ( pArc->GetAngCenter() > 0) ;
         double dRad = pArc->GetRadius() ;
         if ( m_Params.m_nWorkSide == MILL_WS_LEFT)
            dRad += m_TParams.m_dDiam / 2 * ( bCCW ? 1 : -1) ;
         else if ( m_Params.m_nWorkSide == MILL_WS_RIGHT)
            dRad += m_TParams.m_dDiam / 2 * ( bCCW ? -1 : 1) ;
        // se raggio molto piccolo è uno spigolo
         if ( dRad < CORNER_RAG) {
            double dMin = dJointLen - CORNER_DIST - dTabLen ;
            double dMax = dJointLen + dEntLen + CORNER_DIST ;
            PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
         }
        // se raggio è piccolo
         else if ( dRad < RAD_MIN) {
            double dMin = dJointLen - dTabLen ;
            double dMax = dJointLen + dEntLen ;
            PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
         }
      }
     // aggiorno lunghezza alla giunzione con la successiva
      dJointLen += dEntLen ;
     // verifico se angolo tra le entità
      Vector3d vtTg1 ; pCurrCrv->GetEndDir( vtTg1) ;
      Vector3d vtTg2 ; pNextCrv->GetStartDir( vtTg2) ;
      if ( abs( ( vtTg1 ^ vtTg2) * vtExtr) > sin( CORNER_ANG * DEGTORAD)) {
         double dMin = dJointLen - CORNER_DIST - dTabLen ;
         double dMax = dJointLen + CORNER_DIST ;
         PeriodicIntervalsSubract( ivTabs, dLen, dMin, dMax) ;
      } 
     // passo al successivo
      pCurrCrv = pNextCrv ;
      if ( bContinue) {
         pNextCrv = pCompo->GetNextCurve() ;
         if ( pNextCrv == nullptr  &&  pCompo->IsClosed()) {
            pNextCrv = pCompo->GetFirstCurve() ;
            bContinue = false ;
         }
      }
      else
         pNextCrv = nullptr ;
   }

  // determino posizioni di inizio dei Tabs
   double dLastIns = -1 - 2 * dTabLen ;
   double dNextTab = 0.5 * tdTabs.m_dBottomLen ;
   double dCurrLen = 0 ;
   while ( dCurrLen + dNextTab < dLen) {
      double dPos = dCurrLen + dNextTab ;
      double dPrev, dNext ;
      if ( ivTabs.IsInside( dPos)) {
         vdTabs.emplace_back( dPos) ;
         dLastIns = dPos ;
      }
      else if ( ivTabs.GetPrevNearest( dPos, dPrev)  &&  dPrev > dLastIns + 1.5 * dTabLen) {
         vdTabs.emplace_back( dPrev) ;
         dLastIns = dPrev ;
      }
      else if ( ivTabs.GetNextNearest( dPos, dNext)  &&  dNext > dLastIns + dTabLen) {
         vdTabs.emplace_back( dNext) ;
         dLastIns = dNext ;
      }
      dCurrLen += dNextTab + dTabLen ;
      dNextTab = tdTabs.m_dBottomLen ;
   }

  // recupero posizioni tabs adiacenti di precedenti lavorazioni, se accettabili 
   DBLVECTOR vdAdj ;
   double dMaxDist = m_TParams.m_dDiam + 10. ;
   BBox3d b3Mill ;
   m_pGeomDB->GetGlobalBBox( m_nOwnerId, b3Mill) ;
   b3Mill.Expand( dMaxDist) ;
   int nOpeId = m_pMchMgr->GetNextActiveOperation( m_pMchMgr->GetPhaseDisposition( m_nPhase)) ;
   while ( nOpeId != GDB_ID_NULL  &&  m_pMchMgr->GetOperationPhase( nOpeId) == m_nPhase) {
      if ( nOpeId != m_nOwnerId) {
         int nTabId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstNameInGroup( nOpeId, MCH_TABS)) ;
         while ( nTabId != GDB_ID_NULL) {
            Point3d ptCen ;
            if ( ExeCenterPoint( nTabId, GDB_ID_ROOT, ptCen)  &&  b3Mill.EnclosesXY( ptCen)) {
              // porto il centro alla quota del percorso
               ptCen += vtExtr * ( dDepth - m_Params.m_dTabHeight) ;
              // calcolo la distanza del centro dal percorso
               double dDist ; double dPar, dAdjLen ; int nFlag ;
               DistPointCurve distPC( ptCen, *pCompo) ;
               if ( distPC.GetDist( dDist)  &&  dDist < dMaxDist  &&
                    distPC.GetParamAtMinDistPoint( 0, dPar, nFlag)  &&
                    pCompo->GetLengthAtParam( dPar, dAdjLen)) {
                  double dPos = dAdjLen - dTabLen / 2 ;
                  if ( dPos < 0)
                     dPos += dLen ;
                  double dPrev, dNext ;
                  if ( ivTabs.IsInside( dPos))
                     vdAdj.emplace_back( dPos) ;
                  else if ( ivTabs.GetPrevNearest( dPos, dPrev)  &&  abs( dPos - dPrev) <= dTabLen / 2)
                     vdAdj.emplace_back( dPrev) ;
                  else if ( ivTabs.GetNextNearest( dPos, dNext)  &&  abs( dNext - dPos) <= dTabLen / 2)
                     vdAdj.emplace_back( dNext) ;
               }
            }
            nTabId = m_pGeomDB->GetNext( nTabId) ;
         }
      }
      nOpeId = m_pMchMgr->GetNextActiveOperation( nOpeId) ;
   }

  // correggo posizione tabs per eventuali adiacenti
   if ( ! vdAdj.empty()) {
     // ordino le posizioni adiacenti in senso crescente lungo la lavorazione
      sort( vdAdj.begin(), vdAdj.end()) ;
     // se non sono presenti tabs
      if ( vdTabs.empty()) {
         for ( int i = 0 ; i < int( vdAdj.size()) && i < m_Params.m_nTabMax ; ++ i) {
            vdTabs.emplace_back( vdAdj[i]) ;
         }
      }
     // altrimenti
      else {
        // per ogni posizione adiacente
         for ( int i = 0 ; i < int( vdAdj.size()) ; ++ i) {
            double dPos = vdAdj[i] ;
           // cerco quale posizione già definita sostituire
            for ( int j = 0 ; j < int( vdTabs.size()) ; ++ j) {
               if ( abs( dPos - vdTabs[j]) < EPS_SMALL)
                  ;
               else if ( dPos < vdTabs[j]) {
                  if ( j == 0)
                     vdTabs[j] = dPos ;
                  else { 
                     if ( abs( dPos - vdTabs[j-1]) < abs( vdTabs[j] - dPos))
                        vdTabs[j-1] = dPos ;
                     else
                        vdTabs[j] = dPos ;
                  }
                  break ;
               }
               else if ( j == int( vdTabs.size()) - 1) {
                  vdTabs[j] = dPos ;
                  break ;
               }
            }
         }
      }
   }

  // inserisco geometria ausiliaria per i tabs
   for ( auto& dPos : vdTabs) {
     // recupero la posizione
      double dU ;
      Point3d ptCen ;
      if ( pCompo->GetParamAtLength( dPos + dTabLen / 2, dU)  &&
           pCompo->GetPointD1D2( dU, ICurve::FROM_MINUS, ptCen)) {
        // porto il centro alla quota del tab
         ptCen -= vtExtr * ( dDepth - m_Params.m_dTabHeight) ;
        // creo il cerchio
         PtrOwner<ICurveArc> pCircle( CreateCurveArc()) ;
         if ( ! IsNull( pCircle)  &&  pCircle->Set( ptCen, vtExtr, m_TParams.m_dDiam / 2)) {
            int nCircId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nTabsId, Release( pCircle)) ;
            m_pGeomDB->SetMaterial( nCircId, AQUA) ;
         }
      }
   }

  // aggiungo la posizione tappo
   vdTabs.emplace_back( dLen + m_dAddedOverlap + 100.) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
  // lunghezze dei tratti di oscillazione
   double vLen[4] = { 0,
                      tdTabs.m_dRampLen,
                      tdTabs.m_dRampLen + tdTabs.m_dTopLen,
                      tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
  // lunghezza della linea
   double dLen ; pLine->GetLength( dLen) ;
  // lunghezza corrente sulla linea
   double dCurrLen = 0 ;
  // indice corrente di posizione
   int nI = 0 ;
  // emissione oscillazioni
   while ( dCurrLen < dLen - EPS_ZERO  &&  nI < int( vdTabs.size())) {
     // lunghezze di riferimento dei tratti di oscillazione
      double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
     // lunghezza rimanente
      double dNextLen = dLen - dCurrLen ;
     // se inizio è sul primo tratto (parte piatta in basso)
      if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[0] ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[0] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul secondo tratto (rampa ascendente)
      else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[1] ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[1] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul terzo tratto (parte piatta in alto)
      else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[2] ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[2] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti è sul quarto tratto (rampa discendente)
      else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
        // se fine linea è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 = pLine->GetEnd() ;
            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // se fine linea è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[3] ;
            Point3d ptP3 = pLine->GetEnd() ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine linea è oltre
         else {
            dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[3] ;
            double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti passo all'intervallo successivo
      else
         ++ nI ;
   }
   return true ;
}         

//----------------------------------------------------------------------------
bool
Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
{
  // lunghezze dei tratti di oscillazione
   double vLen[4] = { 0,
                      tdTabs.m_dRampLen,
                      tdTabs.m_dRampLen + tdTabs.m_dTopLen,
                      tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
  // parametri dell'arco
   Point3d ptCen = pArc->GetCenter() ;
   double dAngCen = pArc->GetAngCenter() ;
   Vector3d vtN = pArc->GetNormVersor() ;
   double dLen ; pArc->GetLength( dLen) ;
  // lunghezza corrente sull'arco
   double dCurrLen = 0 ;
  // indice corrente di posizione
   int nI = 0 ;
  // emissione oscillazioni
   while ( dCurrLen < dLen - EPS_ZERO  &&  nI < int( vdTabs.size())) {
     // lunghezze di riferimento dei tratti di oscillazione
      double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
     // lunghezza rimanente
      double dNextLen = dLen - dCurrLen ;
     // se inizio è sul primo tratto (parte piatta in basso)
      if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
        // se fine arco è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine arco è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[0] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine arco è oltre
         else {
            dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[0] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul secondo tratto (rampa ascendente)
      else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
        // se fine arco è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine arco è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[1] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine arco è oltre
         else {
            dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[1] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // se inizio è sul terzo tratto  (parte piatta in alto)
      else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
        // se fine arco è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine arco è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[2] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine arco è oltre
         else {
            dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[2] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti è sul quarto tratto (rampa discendente)
      else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
        // se fine arco è entro il tratto
         if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen += dNextLen ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // se fine arco è alla fine del tratto 
         else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
            dCurrLen = dLen ;
            m_dCurrTabsLen = vLenRef[3] ;
            Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
            double dCurrAngCen = dAngCen * dNextLen / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti fine arco è oltre
         else {
            dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
            m_dCurrTabsLen = vLenRef[3] ;
            double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
            Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
            double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
            if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
               return false ;
         }
      }
     // altrimenti passo all'intervallo successivo
      else
         ++ nI ;
   }
   return true ;
}

//----------------------------------------------------------------------------
double
Milling::GetRadiusForStartEndElevation( bool bExtra) const
{
  // se da non estendere
   if ( ! bExtra)
      return ( 0.5 * m_TParams.m_dTDiam) ;
  // aumentato
   double dDeltaRad = min( DELTA_ELEV_RAD, 0.5 * m_TParams.m_dTDiam) ;
   return ( 0.5 * m_TParams.m_dTDiam + dDeltaRad) ;
}

//----------------------------------------------------------------------------
bool
Milling::GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr) const
{
  // per frese che lavorano di testa
   if ( m_TParams.m_nType == TT_MILL_STD) {
     // eseguo verifica in direzione utensile
      double dToolRad = m_TParams.m_dTDiam / 2 ;
      double dToolLen = m_TParams.m_dMaxMat ;
      double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ;
      double dTemp ;
      if ( ! GetElevation( m_nPhase, ptP - dToolDeltaLen * vtTool, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtTool, dTemp))
         return false ;
      return ( dTemp < 10 * EPS_SMALL) ;
   }
  // per frese che lavorano solo di fianco e per lame
   else {
     // eseguo verifica in direzione correzione
      double dToolRad = m_TParams.m_dTDiam / 2 ;
      double dToolThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
      double dToolDeltaLen = m_TParams.m_dTLen - m_TParams.m_dLen ;
      double dTemp ;
      if ( ! GetElevation( m_nPhase, ptP - dToolDeltaLen * vtTool, vtTool, dToolRad, dToolThick, MIN_SAFEDIST, vtRetr, dTemp))
         return false ;
      return ( dTemp < 10 * EPS_SMALL) ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dSafeZ) const
{
  // per frese normali
   if ( m_TParams.m_nType == TT_MILL_STD) {
     // determino se la posizione è fuori dal grezzo (considero movimento fresa lungo il suo asse)
      double dTemp ;
      double dToolRad = m_TParams.m_dTDiam / 2 ;
      double dToolLen = m_TParams.m_dMaxMat ;
      if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtTool, dTemp))
         return false ;
      return ( dTemp < 10 * EPS_SMALL) ;
   }
  // per lame e frese che non lavorano di testa
   else {
     // determino se la posizione è fuori dal grezzo (considero movimento utensile in +/- Z)
      double dTemp ;
      Vector3d vtMove = ( m_bAboveHead ? Z_AX : -Z_AX) ;
      Vector3d vtSafe = vtRetr ; vtSafe.z = 0 ; vtSafe.Normalize() ;
      double dToolRad = m_TParams.m_dTDiam / 2 ;
      double dToolLen = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : m_TParams.m_dMaxMat) ;
      bool bOut = true ;
      if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL) {
         bOut = false ;
         if ( ! m_bTiltingTab)
            return false ;
      }
     // se tavola basculante (o asse ralla) e non esterno, provo in direzione utensile
      if ( m_bTiltingTab  &&  ! bOut) {
         vtMove = vtTool ;
         if ( ! GetElevation( m_nPhase, ptP, vtTool, dToolRad, dToolLen, MIN_SAFEDIST, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL)
            return false ;
      }
      return true ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const
{
  // derivo punti più bassi dell'utensile
   Vector3d vtDown = -FromUprightOrtho( vtTool) ;
   Point3d ptP1 = ptP + vtDown * 0.5 * m_TParams.m_dTDiam ;
   Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ;
  // determino la posizione dei punti rispetto al grezzo
  // ciclo sui grezzi
   int nRawId = m_pMchMgr->GetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
     // se il grezzo compare nella fase
      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
         int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
         BBox3d b3Raw ;
         m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
         if ( ! b3Raw.IsEmpty()) {
            if ( ptP1.z < b3Raw.GetMax().z + 10 * EPS_SMALL  ||
                 ptP2.z < b3Raw.GetMax().z + 10 * EPS_SMALL)
            return false ;
         }
      }
      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const
{
  // derivo punti più alti dell'utensile
   Vector3d vtUp = FromUprightOrtho( vtTool) ;
   Point3d ptP1 = ptP + vtUp * 0.5 * m_TParams.m_dTDiam ;
   Point3d ptP2 = ptP1 + vtTool * ((( m_TParams.m_nType & TF_SAWBLADE) == 0) ? m_TParams.m_dLen : m_TParams.m_dThick) ;
  // determino la posizione dei punti rispetto al grezzo
  // ciclo sui grezzi
   int nRawId = m_pMchMgr->GetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
     // se il grezzo compare nella fase
      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
         int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
         BBox3d b3Raw ;
         m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
         if ( ! b3Raw.IsEmpty()) {
            if ( ptP1.z > b3Raw.GetMin().z - 10 * EPS_SMALL ||
                 ptP2.z > b3Raw.GetMin().z - 10 * EPS_SMALL)
            return false ;
         }
      }
      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial)
{
  // verifico curva
   if ( pCompo == nullptr)
      return false ;
  // versore correzione nullo per default
   Vector3d vtCorr ;
  // se utensile non centrato, calcolo del versore correzione
   if ( m_Params.m_nWorkSide != MILL_WS_CENTER)
      vtCorr = CalcCorrDir( pCompo, dU, bInvertSide, bSawSpecial) ;
  // imposto versore correzione
   SetCorrDir( vtCorr) ;
  // se rinvio da sotto in uso, non devo impostare direzione aux da correzione
   if ( m_bAggrBottom)
      return true ;
  // se impostato uso direttamente da lavorazione, imposto anche come versore aux
   if ( m_Params.m_nSolCh == MCH_SCC_ADIR_NEAR  ||  m_Params.m_nSolCh == MCH_SCC_ADIR_FAR) {
      SetAuxDir( vtCorr) ;
      return true ;
   }
  // se standard o nullo o suo opposto
   if ( m_Params.m_nSolCh == MCH_SCC_STD  ||  m_Params.m_nSolCh == MCH_SCC_NONE  ||  m_Params.m_nSolCh == MCH_SCC_OPPOSITE) {
     // verifico se richiesto dalla testa
      if ( m_nHeadSolCh == MCH_SCC_ADIR_NEAR  ||  m_nHeadSolCh == MCH_SCC_ADIR_FAR) {
         SetAuxDir( vtCorr) ;
         return true ;
      }
   }
  // reset o assegnamento da parametro di lavorazione nelle UserNotes
   Vector3d vtAux ;
   if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTAUXDIR, vtAux))
      vtAux.Normalize() ;
   SetAuxDir( vtAux) ;

   return true ;
}

//----------------------------------------------------------------------------
Vector3d
Milling::CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide, bool bSawSpecial) const
{
  // verifico curva
   if ( pCompo == nullptr)
      return V_NULL ;
  // se utensile centrato, direzione di correzione nulla
   if ( m_Params.m_nWorkSide == MILL_WS_CENTER)
      return V_NULL ;
  // se speciale lame, aggiusto il parametro di calcolo
   if ( bSawSpecial  &&  ( m_TParams.m_nType & TF_SAWBLADE) != 0) {
      if ( pCompo->GetCurveCount() == 3)
         dU = 1.5 ;
      else if ( pCompo->GetCurveCount() == 2) {
         double dLen0 ; pCompo->GetCurve( 0)->GetLength( dLen0) ;
         double dLen1 ; pCompo->GetCurve( 1)->GetLength( dLen1) ;
         dU = ( dLen0 > dLen1 ? 0.5 : 1.5) ;
      }
   }
  // angolo di rotazione da tg a versore corr/aux
   bool bCcwRot = (( m_Params.m_nWorkSide == MILL_WS_LEFT) != bInvertSide) ;
   double dCaRot = ( bCcwRot ? ANG_RIGHT : -ANG_RIGHT) ; 
  // dominio parametrico della curva
   double dUs, dUe ;
   pCompo->GetDomain( dUs, dUe) ;
  // se inizio
   if ( dU < dUs + EPS_ZERO) {
     // recupero la tangente dopo
      Point3d ptP ;
      Vector3d vtN ;
      pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP, vtN) ;
      vtN.Rotate( m_vtTool, dCaRot) ;
      return vtN ;
   }
  // se fine
   else if ( dU > dUe - EPS_ZERO) {
     // recupero la tangente prima
      Point3d ptP ;
      Vector3d vtN ;
      pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP, vtN) ;
      vtN.Rotate( m_vtTool, dCaRot) ;
      return vtN ;
   }
  // altrimenti
   else {
     // recupero la tangente prima e dopo il punto
      Point3d ptP1, ptP2 ;
      Vector3d vtT1, vtT2 ;
      pCompo->GetPointTang( dU, ICurve::FROM_MINUS, ptP1, vtT1) ;
      pCompo->GetPointTang( dU, ICurve::FROM_PLUS, ptP2, vtT2) ;
     // se coincidono 
      if ( AreSameVectorApprox( vtT1, vtT2)) {
         Vector3d vtN = vtT1 ;
         vtN.Rotate( m_vtTool, dCaRot) ;
         return vtN ;
      }
     // se sono opposte
      else if ( AreOppositeVectorApprox( vtT1, vtT2)) {
         Vector3d vtN = ( bCcwRot ? vtT2 : vtT1) ;
         return vtN ;
      }
     // altrimenti
      else {
         Vector3d vtN = ( vtT1 + vtT2) / 2 ;
         vtN.Rotate( m_vtTool, dCaRot) ;
         return vtN ;
      }
   }
}

//----------------------------------------------------------------------------
bool
Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) const
{
  // determino opzioni di offset
   int nFlag = ICurve::OFF_FILLET ;
   if ( pCompo->IsClosed()) {
      Vector3d vtStart ; pCompo->GetStartDir( vtStart) ;
      Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ;
      if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD)))
         nFlag |= ICurve::OFF_FORCE_OPEN ;
   }
   if ( m_Params.m_bLeaveTab  ||  m_Params.m_bOscEnable)
      nFlag |= ICurve::OFF_MEDIA_INTDZ ;
  // determino se curva piatta e recupero suo vettore estrusione
   Plane3d plPlane ;
   bool bIsFlat = pCompo->IsFlat( plPlane, false, 10 * EPS_SMALL) ;
   Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
  // se curva piatta con estrusione non perpendicolare forzo offset avanzato
   bool bAdvOffs = ( bIsFlat  &&  abs( vtExtr * plPlane.GetVersN()) < cos( 0.1 * DEGTORAD)) ;
  // eseguo offset semplice
   if ( ! bAdvOffs  &&  pCompo->SimpleOffset( dSignOffs, nFlag))
      return true ;
  // eseguo offset avanzato
   if ( bIsFlat) {
      OffsetCurve OffsCrv ;
      if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
         ICurve* pOffs = OffsCrv.GetLongerCurve() ;
         if ( pOffs != nullptr) {
            pCompo->Clear() ;
            pCompo->AddCurve( pOffs) ;
            pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;
            return true ;
         }
         else {
            Point3d ptOffs ;
            Vector3d vtOut ;
            if ( OffsCrv.GetPointOffset( ptOffs, vtOut)) {
               const double MIN_MOVE = 1 ;
               Vector3d vtStart = vtOut ;
               double dStaLen = 10 ;
               Point3d ptStart ;
               if ( pCompo->GetStartPoint( ptStart)) {
                  Vector3d vtTmp = ptOffs - ptStart ;
                  if ( vtTmp.Normalize()) {
                     double dCosA = abs( vtTmp * vtOut) ;
                     dStaLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
                     vtTmp.Rotate( vtExtr, 0, 1) ;
                     if ( vtTmp * vtOut < 0)
                        vtTmp.Invert() ;
                     vtStart = vtTmp ;
                  }
               }
               Vector3d vtEnd = vtOut ;
               double dEndLen = 10 ;
               Point3d ptEnd ;
               if ( pCompo->GetEndPoint( ptEnd)) {
                  Vector3d vtTmp = ptOffs - ptEnd ;
                  if ( vtTmp.Normalize()) {
                     double dCosA = abs( vtTmp * vtOut) ;
                     dEndLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
                     vtTmp.Rotate( vtExtr, 0, 1) ;
                     if ( vtTmp * vtOut < 0)
                        vtTmp.Invert() ;
                     vtEnd = vtTmp ;
                  }
               }
               pCompo->Clear() ;
               pCompo->AddPoint( ptOffs) ;
               pCompo->AddLine( ptOffs + dStaLen * vtStart, false) ;
               pCompo->AddLine( ptOffs + dEndLen * vtEnd) ;
               return true ;
            }
         }
      }
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::TrimExtendCurveToClosedStm( ICurveComposite* pCompo, int nCstmId, bool bInvert)
{
  // dati preparatori
   const ISurfTriMesh* pCstm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nCstmId)) ;
   if ( pCstm == nullptr  ||  ! pCstm->IsClosed())
      return false ;
   Frame3d frCstm ;
   if ( ! m_pGeomDB->GetGlobFrame( nCstmId, frCstm))
      return false ;
   BBox3d b3Tes = pCstm->GetAllTriaBox() ;
   if ( b3Tes.IsEmpty())
      return false ;
   double dTriExtLen ;
   b3Tes.GetDiameter( dTriExtLen) ;

  // inverto offset su centro utensile
   double dCompOffs = 0.5 * m_TParams.m_dDiam * ( ( m_Params.m_nWorkSide == MILL_WS_RIGHT) != bInvert ? 1 : -1) ;
   if ( ! CalcOffset( pCompo, -dCompOffs))
      return false ;
  // porto la curva nel riferimento della superficie
   pCompo->ToLoc( frCstm) ;

  // allungo la curva in testa e coda per essere sicuro che gli estremi siano esterni
   if ( ! pCompo->AddLineTg( dTriExtLen, false)  ||  ! pCompo->AddLineTg( dTriExtLen, true))
      return false ;
  // calcolo intersezioni con superficie chiusa
   INTDBLVECTOR vInters ;
   if ( ! IntersCurveSurfTmExt( *pCompo, *pCstm, 10 * EPS_SMALL, vInters))
      return false ;
  // prendo prima intersezione entrante e ultima uscente
   double dParStart = -1 ;
   for ( int i = 0 ; i < int( vInters.size()) ; ++ i) {
      if ( vInters[i].first == CSIT_OUT_IN  ||  vInters[i].first == CSIT_ON_IN) {
         dParStart = vInters[i].second ;
         break ;
      }
   }
   double dParEnd = -1 ;
   for ( int i = int( vInters.size()) - 1 ; i >= 0 ; -- i) {
      if ( vInters[i].first == CSIT_IN_OUT  ||  vInters[i].first == CSIT_IN_ON) {
         dParEnd = vInters[i].second ;
         break ;
      }
   }
  // eseguo trim ed unisco le eventuali parti allineate
   if ( ! pCompo->TrimStartEndAtParam( dParStart, dParEnd)  ||
        ! pCompo->MergeCurves(10 * EPS_SMALL, 10 * EPS_ANG_SMALL))
      return false ;

  // riporto la curva in globale
   pCompo->ToGlob( frCstm) ;
  // ritorno in centro utensile
   if ( ! CalcOffset(pCompo, dCompOffs))
      return false ;

   return true ;
}