EgtMachKernel/Milling.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : Milling.cpp         Data : 07.06.15          Versione : 1.6f2
// Contenuto : Implementazione gestione fresature.
//
//
//
// Modifiche : 07.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "Milling.h"
#include "MachiningConst.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/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//----------------------------------------------------------------------------
USEROBJ_REGISTER( "EMkMilling", 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_Params = m_Params ;
         pMill->m_TParams = m_TParams ;
      }
      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 ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::Save( STRVECTOR& vString) const
{
   try {
      int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 2 ;
      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 ;
   }
   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 ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Milling::Milling( void)
{
   m_Params.m_sName = "*" ;
   m_Params.m_sToolName = "*" ;
   m_TParams.m_sName = "*" ;
   m_TParams.m_sHead = "*" ;
   m_nMills = 0 ;
}

//----------------------------------------------------------------------------
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 :
      m_Params.m_bInvert = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_WORKSIDE :
      if ( ! m_Params.VerifyWorkSide( nVal))
         return false ;
      m_Params.m_nWorkSide = nVal ;
      return true ;
   case MPA_STEPTYPE :
      if ( ! m_Params.VerifyStepType( nVal))
         return false ;
      m_Params.m_nStepType = nVal ;
      return true ;
   case MPA_LEADINTYPE :
      if ( ! m_Params.VerifyLeadInType( nVal))
         return false ;
      m_Params.m_nLeadInType = nVal ;
      return true ;
   case MPA_LEADOUTTYPE :
      if ( ! m_Params.VerifyLeadOutType( nVal))
         return false ;
      m_Params.m_nLeadOutType = nVal ;
      return true ;
   case MPA_SCC :
      if ( ! m_Params.VerifySolCh( nVal))
         return false ;
      m_Params.m_nSolCh = 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)
         m_Params.m_dSpeed = 0 ;
      else
         m_Params.m_dSpeed = dVal ;
      return true ;
   case MPA_FEED :
      if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dFeed = 0 ;
      else
         m_Params.m_dFeed = dVal ;
      return true ;
   case MPA_STARTFEED :
      if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dStartFeed = 0 ;
      else
         m_Params.m_dStartFeed = dVal ;
      return true ;
   case MPA_ENDFEED :
      if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dEndFeed = 0 ;
      else
         m_Params.m_dEndFeed = dVal ;
      return true ;
   case MPA_TIPFEED :
      if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dTipFeed = 0 ;
      else
         m_Params.m_dTipFeed = dVal ;
      return true ;
   case MPA_OFFSR :
      if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dOffsR = UNKNOWN_PAR ;
      else
         m_Params.m_dOffsR = dVal ;
      return true ;
   case MPA_OFFSL :
      if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
         m_Params.m_dOffsL = UNKNOWN_PAR ;
      else
         m_Params.m_dOffsL = dVal ;
      return true ;
   case MPA_DEPTH :
      m_Params.m_sDepth = ToString( dVal) ;
      return true ;
   case MPA_STARTPOS :
      m_Params.m_dStartPos = dVal ;
      return true ;
   case MPA_OVERLAP :
      m_Params.m_dOverlap = dVal ;
      return true ;
   case MPA_STEP :
      m_Params.m_dStep = dVal ;
      return true ;
   case MPA_STARTADDLEN :
      m_Params.m_dStartAddLen = dVal ;
      return true ;
   case MPA_ENDADDLEN :
      m_Params.m_dEndAddLen = dVal ;
      return true ;
   case MPA_LITANG :
      m_Params.m_dLiTang = dVal ;
      return true ;
   case MPA_LIPERP :
      m_Params.m_dLiPerp = dVal ;
      return true ;
   case MPA_LIELEV :
      m_Params.m_dLiElev = dVal ;
      return true ;
   case MPA_LICOMPLEN :
      m_Params.m_dLiCompLen = dVal ;
      return true ;
   case MPA_LOTANG :
      m_Params.m_dLoTang = dVal ;
      return true ;
   case MPA_LOPERP :
      m_Params.m_dLoPerp = dVal ;
      return true ;
   case MPA_LOELEV :
      m_Params.m_dLoElev = dVal ;
      return true ;
   case MPA_LOCOMPLEN :
      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 ;
      m_Params.m_sToolName = sVal ;
      m_Params.m_ToolUuid = pTdata->m_Uuid ;
      m_TParams = *pTdata ;
      } break ;
   case MPA_DEPTH_STR :
      m_Params.m_sDepth = sVal ;
      return true ;
   case MPA_SYSNOTES :
      m_Params.m_sSysNotes = sVal ;
      break ;
   case MPA_USERNOTES :
      m_Params.m_sUserNotes = sVal ;
      break ;
   default :
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::SetGeometry( const SELVECTOR& vIds)
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // reset della geometria corrente
   m_vId.clear() ;
  // verifico che gli identificativi rappresentino delle entità ammissibili
   for ( const auto& Id : vIds) {
     // test sull'entità
      int nSubs ;
      if ( ! VerifyGeometry( Id, nSubs)) {
         string sOut = "Entity " + ToString( Id) + " skipped by Milling" ;
         LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
         continue ;
      }
     // posso aggiungere alla lista
      //if ( nSubs == 0)
         m_vId.emplace_back( Id) ;
      //else {
      //   for ( int i = 0 ; i < nSubs ; ++ i)
      //      m_vId.emplace_back( Id.nId, i) ;
      //}
   }
   return ( ! m_vId.empty()) ;
}

//----------------------------------------------------------------------------
bool
Milling::Preview( bool bRecalc)
{
  // reset numero percorsi di lavoro generati
   m_nMills = 0 ;

   return false ;
}

//----------------------------------------------------------------------------
bool
Milling::Apply( 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()) {
      LOG_INFO( GetEMkLogger(), "Error in Sawing : UpdateToolData failed") ;
      return false ;
   }

  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
   if ( bChain  &&  ! Chain( nAuxId))
      return false ;

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

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

  // se lavorazione vuota, esco
   if ( m_nMills == 0)
      return true ;

  // calcolo gli assi macchina
   if ( ! CalculateAxesValues())
      return false ;

  // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
   if ( ! AdjustStartEndMovements())
      return false ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::GetParam( int nType, bool& bVal) const
{
   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_SCC :
      nVal = m_Params.m_nSolCh ;
      return true ;
   }
   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_OVERLAP :
      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_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 ;
   }
   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 ;
   }
   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
   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
   if ( pTdata == nullptr)
      return false ;
  // aggiorno i parametri
   m_TParams = *pTdata ;
   if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
      string sLog = "Warning in Milling : tool name changed (" +
                    m_Params.m_sToolName + "->" + m_TParams.m_sName +")" ;
      LOG_INFO( GetEMkLogger(), sLog.c_str()) ;
   }
   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)
{
  // ammessi : curve o facce di polymesh

  // per ora accetto solo curve
   const ICurve* pCurve = nullptr ;
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   // se direttamente la curva
   if ( Id.nSub == SEL_SUB_ALL) {
      pCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ;
      if ( pCurve != nullptr) {
         if ( pCurve->GetType() == CRV_COMPO)
            nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
         else
            nSubs = 0 ;
      }
   }
   // altrimenti sottocurva di composita
   else {
      const ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( Id.nId)) ;
      if ( pCompo != nullptr)
         pCurve = pCompo->GetCurve( Id.nSub) ;
      nSubs = 0 ;
   }
   return ( pCurve != nullptr) ;
}

//----------------------------------------------------------------------------
ICurve*
Milling::GetCurve( SelData Id)
{
  // ammessi : curve o facce di polymesh
   // nel caso di facce si deve recuperare la linea di base

  // per ora accetto solo curve
   PtrOwner<ICurve> pCurve ;
   // se direttamente curva
   if ( Id.nSub == SEL_SUB_ALL) {
     // recupero e duplico la curva
      const ICurve* pOriCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ;
      if ( pOriCurve != nullptr)
         pCurve.Set( pOriCurve->Clone()) ;
   }
   // altrimenti sottocurva di composita
   else {
     // recupero la composita
      const ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( Id.nId)) ;
      if ( pCompo != nullptr) {
        // duplico la curva semplice
         const ICurve* pOriCurve = ::GetCurve( pCompo->GetCurve( Id.nSub)) ;
         if ( pOriCurve != nullptr) {
            pCurve.Set( pOriCurve->Clone()) ;
           // recupero estrusione e spessore
            Vector3d vtExtr ;
            if ( pCompo->GetExtrusion( vtExtr))
               pCurve->SetExtrusion( vtExtr) ;
            double dThick ;
            if ( pCompo->GetThickness( dThick))
               pCurve->SetThickness( dThick) ;
         }
      }
   }
   if ( IsNull( pCurve))
      return nullptr ;
  // ne recupero il riferimento globale
   Frame3d frGlob ;
   if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
      return nullptr ;
  // la porto in globale
   pCurve->ToGlob( frGlob) ;
  // la restituisco
   return Release( pCurve) ;
}

//----------------------------------------------------------------------------
bool
Milling::Chain( int nGrpDestId)
{
  // vettore puntatori alle curve
   typedef PtrOwner<ICurve> POWNCURVE ;
   typedef std::vector<POWNCURVE> POCRVVECTOR ;
   POCRVVECTOR vpCrvs ;
   vpCrvs.reserve( m_vId.size()) ;
  // recupero tutte le curve e le porto in globale
   for ( const auto& Id : m_vId) {
     // prendo curva
      vpCrvs.emplace_back( GetCurve( Id)) ;
     // ne verifico la validità
      if ( IsNull( vpCrvs.back())) {
         string sOut = "Entity " + ToString( Id) + " skipped by Milling" ;
         LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
         vpCrvs.back().Reset() ;
      }
   }
  // 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( m_vId[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)  &&  fabs( dTemp) > fabs( 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) ; 
     // 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)
{
  // non devo fare alcunché
   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)) ;

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

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

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

  // eventuale allungamento/accorciamento dell'inizio
   if ( abs( m_Params.m_dStartAddLen) > EPS_SMALL) {
      if ( m_Params.m_dStartAddLen > 0) {
         if ( ! pCompo->ExtendStartByLen( m_Params.m_dStartAddLen))
            return false ;
      }
      else {
         if ( ! pCompo->TrimStartAtLen( - m_Params.m_dStartAddLen))
            return false ;
      }
   }

  // eventuale allungamento/accorciamento della fine
   if ( abs( m_Params.m_dEndAddLen) > EPS_SMALL) {
      if ( m_Params.m_dEndAddLen > 0) {
         if ( ! pCompo->ExtendEndByLen( m_Params.m_dEndAddLen))
            return false ;
      }
      else {
         double dLen ;
         if ( ! pCompo->GetLength( dLen)  ||  ! pCompo->TrimEndAtLen( dLen + m_Params.m_dEndAddLen))
            return false ;
      }
   }

  // se utensile non centrato, eseguo correzione raggio utensile ed eventuale offset
   double dOffs = 0.5 * m_TParams.m_dTDiam + GetOffsR() ;
   if ( m_Params.m_nWorkSide != MILL_WS_CENTER  &&  abs( dOffs) > EPS_SMALL) {
      double dSignOffs = ( m_Params.m_nWorkSide == MILL_WS_RIGHT) ? dOffs : - dOffs ;
      if ( ! pCompo->SimpleOffset( dSignOffs, ICurve::OFF_EXTEND)){
         LOG_INFO( GetEMkLogger(), "Error in Milling : SimpleOffset not computable") ;
         return false ;
      }
   }

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

  // recupero il box del grezzo in globale
   BBox3d b3Raw ;
   if ( ! GetRawGlobBox( m_nPhase, nPathId, b3Raw)  ||  b3Raw.IsEmpty()) {
      LOG_INFO( GetEMkLogger(), "Error in SawFinishing : Empty RawBox") ;
      return false ;
   }

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

  // valuto l'espressione dell'affondamento
   ExeLuaSetGlobNumVar( "TH", ( dThick >= 0 ? 0 : -dThick)) ;
   ExeLuaSetGlobNumVar( "RB", dRbDist) ;
   double dDepth ;
   if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) {
      LOG_INFO( GetEMkLogger(), "Error in Milling : Depth not computable") ;
      return false ;
   }
  // sottraggo eventuale offset longitudinale
   dDepth -= GetOffsL() ;
  // verifico di non superare il massimo materiale
   if ( dDepth > m_TParams.m_dMaxMat) {
      LOG_INFO( GetEMkLogger(), "Error in Milling : Depth bigger than MaxMaterial") ;
      return false ;
   }

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

  // eventuale approssimazione con segmenti di linea

   bool bSplitArcs = ( m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() == SPLAR_ALWAYS) ;
   if ( bSplitArcs) {
      const double ANG_TOL_MAX_DEG = 90 ;
      PolyLine PL ;
      if ( pCompo->ApproxWithLines( 50 * EPS_SMALL, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL)) {
        // sostituisco le linee alle curve originali
         pCompo->Clear() ;
         pCompo->FromPolyLine( PL) ;
        // riassegno estrusione e spessore
         pCompo->SetExtrusion( vtExtr) ;
         pCompo->SetThickness( dThick) ;
      }
   }

  // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
   const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ;
   int nMaxInd = pCompo->GetCurveCount() - 1 ;
   for ( int i = 0 ; i <= nMaxInd ; ++ i) {
     // se arco con angolo al centro oltre il limite, lo divido a metà
      const ICurveArc* pArc = GetCurveArc( pCompo->GetCurve( i)) ;
      if ( pArc != nullptr  &&  abs( pArc->GetAngCenter()) > MAX_ANG_CEN) {
         pCompo->AddJoint( i + 0.5) ;
         ++ i ;
         ++ nMaxInd ;
      }
   }

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

  // calcolo il versore fresa
   Vector3d vtTool = Z_AX ;
   if ( ! vtExtr.IsSmall())
      vtTool = vtExtr ;

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

  // Imposto dati comuni
   SetPathId( nPxId) ;
   SetToolDir( vtTool) ;
  // recupero distanza di sicurezza
   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
  // lunghezza di approccio/retrazione
   double dAppr = m_Params.m_dStartPos ;

  // ciclo sulle curve elementari
   bool bClosed = pCompo->IsClosed() ;
   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( ::GetCurve( pCrvC->Clone())) ;
      if ( IsNull( pCurve))
         return false ;
     // aggiungo affondamento
      pCurve->Translate( - vtTool * dDepth) ;
     // calcolo elevazione
      double dElev ;
      Point3d ptStart, ptMid, ptEnd ;
      pCurve->GetStartPoint( ptStart) ;
      pCurve->GetMidPoint( ptMid) ;
      pCurve->GetEndPoint( ptEnd) ;
      if ( ! GetElevation( m_nPhase, ptStart, ptMid, ptEnd, vtTool, dElev)) {
         LOG_INFO( GetEMkLogger(), "Error in Milling : Entity GetElevation") ;
         return false ;
      }
      if ( dElev < EPS_SMALL  &&  AreSameVectorApprox( vtExtr, Z_AX)) {
         BBox3d b3Crv ;
         pCurve->GetLocalBBox( b3Crv) ;
         dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z) ;
      }
     // se prima entità, approccio e affondo
      if ( i == 0) {
        // dati inizio entità
         Point3d ptStart ;
         pCurve->GetStartPoint( ptStart) ;
         Vector3d vtStart ;
         pCurve->GetStartDir( vtStart) ;
        // determino inizio attacco
         Point3d ptP1 ;
         if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, ptP1))
            return false ;
        // aggiungo approccio per frese normali
         if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
            double dStElev ;
            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, dStElev))
               dStElev = dElev ;
            if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr))
               return false ;
           // affondo al punto iniziale
            SetFlag( 0) ;
            SetFeed( GetTipFeed()) ;
            if ( AddLinearMove( ptP1) == GDB_ID_NULL)
               return false ;
         }
        // altrimenti, approccio per lame
         else {
           // affondo al punto iniziale
            SetFlag( 0) ;
            if ( AddRapidStart( ptP1) == GDB_ID_NULL)
               return false ;
         }
        // aggiungo attacco
         SetFeed( GetStartFeed()) ;
         if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, bSplitArcs)) {
            LOG_INFO( GetEMkLogger(), "Error in Milling : LeadIn not computable") ;
            return false ;
         }
      }
     // elaborazioni sulla curva corrente
      if ( pCurve->GetType() == CRV_LINE) {
         ICurveLine* pLine = GetCurveLine( pCurve) ;
         Point3d ptP3 = pLine->GetEnd() ;
         SetFeed( GetFeed()) ;
         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
      }
      else if ( pCurve->GetType() == CRV_ARC) {
         ICurveArc* pArc = GetCurveArc( pCurve) ;
         Point3d ptCen = pArc->GetCenter() ;
         double dAngCen = pArc->GetAngCenter() ;
         Vector3d vtN = pArc->GetNormVersor() ;
         Point3d ptP3 ;
         pArc->GetEndPoint( ptP3) ;
         SetFeed( GetFeed()) ;
         if ( AddArcMove( ptP3, ptCen, dAngCen, vtN) == GDB_ID_NULL)
            return false ;
      }
     // se ultima entità, uscita e retrazione
      if ( i == nMaxInd) {
        // dati fine entità
         Point3d ptEnd ;
         pCurve->GetEndPoint( ptEnd) ;
         Vector3d vtEnd ;
         pCurve->GetEndDir( vtEnd) ;
        // aggiungo uscita
         Point3d ptP1 ;
         SetFeed( GetStartFeed()) ;
         if ( ! AddLeadOut( ptEnd, vtEnd, vtExtr, ptP1, bSplitArcs)) {
            LOG_INFO( GetEMkLogger(), "Error in Milling : LeadOut not computable") ;
            return false ;
         }
        // aggiungo retrazione per frese normali
         if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
            double dEndElev ;
            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, dEndElev))
               dEndElev = dElev ;
           // aggiungo retrazione
            if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr))
               return false ;
         }
        // per lame non è necessario
      }
   }

  // incremento numero di fresate
   ++ m_nMills ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
   // se distanza di sicurezza minore di distanza di inizio
   if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
     // 1 -> punto sopra inizio
      SetFlag( 1) ;
      Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
      if ( AddRapidStart( ptP1) == GDB_ID_NULL)
         return false ;
   }
   else {
     // 1a -> punto sopra inizio
      SetFlag( 1) ;
      Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
      Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ;
      if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
         return false ;
     // 1b -> punto appena sopra inizio
      if ( ( dElev + dAppr) > EPS_SMALL) {
         SetFlag( 0) ;
         if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
{
   if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
     // 4 -> movimento di risalita sopra il punto finale
      SetFeed( GetEndFeed()) ;
      Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
      if ( AddLinearMove( ptP4) == GDB_ID_NULL)
         return false ;
   }
   else {
     // 4a -> movimento di risalita appena sopra il punto finale
      Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
      if ( dElev + dAppr > EPS_SMALL) {
         SetFeed( GetEndFeed()) ;
         if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
            return false ;
      }
     // 4b -> movimento di risalita sopra il punto finale
      Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - dAppr) ;
      if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, Point3d& ptP1)
{
   switch ( m_Params.m_nLeadInType) {
   case MILL_LI_NONE :
      ptP1 = ptStart ;
      return true ;
   case MILL_LI_LINEAR :
   case MILL_LI_TANGENT : {
         if ( m_Params.m_dLiTang < 10 * EPS_SMALL  &&  abs( m_Params.m_dLiPerp) < EPS_SMALL)
            return false ;
         Vector3d vtPerp = vtStart ;
         vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ;
         ptP1 = ptStart - vtStart * m_Params.m_dLiTang + vtPerp * m_Params.m_dLiPerp ;
         return true ;
      }
   case MILL_LI_GLIDE :
      // !!! DA FARE !!!
      return false ;
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
                    const Vector3d& vtN, bool bSplitArcs)
{
  // assegno i parametri
   int nType = m_Params.m_nLeadInType ;
   if ( bSplitArcs) {
      if ( nType == MILL_LI_TANGENT)
         nType = MILL_LI_LINEAR ;
      if ( nType == MILL_LI_HELIX)
         nType = MILL_LI_LINEAR ;     // prevedere un nuovo tipo zig-zag
   }
  // eseguo a seconda del tipo
   switch ( nType) {
   case MILL_LI_NONE :
      return true ;
   case MILL_LI_LINEAR :
      return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
   case MILL_LI_TANGENT :
      {
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ;
         if ( IsNull( pCrv))
            return false ;
         pCrv->Invert() ;
         if ( pCrv->GetType() == CRV_LINE) {
            ICurveLine* pLine = GetCurveLine( pCrv) ;
            Point3d ptP3 = pLine->GetEnd() ;
            return ( AddLinearMove( ptP3, MCH_CL_LEADIN) != GDB_ID_NULL) ;
         }
         else if ( pCrv->GetType() == CRV_ARC) {
            ICurveArc* pArc = GetCurveArc( pCrv) ;
            Point3d ptCen = pArc->GetCenter() ;
            double dAngCen = pArc->GetAngCenter() ;
            Vector3d vtN = pArc->GetNormVersor() ;
            Point3d ptP3 ;
            pArc->GetEndPoint( ptP3) ;
            // se angolo al centro minore del limite, un solo arco
            const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ;
            if ( abs( dAngCen) < MAX_ANG_CEN) {
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
            }
            // altrimenti due archi
            else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){
               Point3d ptMid ;
               pArc->GetMidPoint( ptMid) ;
              // prima metà arco
               if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
              // seconda metà arco
               if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
            }
            // oppure tre archi
            else {
               Point3d ptTmp ;
              // primo terzo
               pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ;
               if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
              // secondo terzo
               ptCen.z = ptTmp.z ;
               pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ;
               if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
              // ultimo terzo
               ptCen.z = ptTmp.z ;
               if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADIN) == GDB_ID_NULL)
                  return false ;
            }
            return true ;
         }
      }
   case MILL_LI_GLIDE :
      // !!! DA FARE !!!
      return false ;
   default :
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                     Point3d& ptP1, bool bSplitArcs)
{
  // assegno i parametri
   int nType = m_Params.m_nLeadOutType ;
   double dTang = m_Params.m_dLoTang ;
   double dPerp = m_Params.m_dLoPerp ;
   if ( nType == MILL_LO_AS_LI) {
      nType = m_Params.m_nLeadInType ;
      dTang = m_Params.m_dLiTang ;
      dPerp = m_Params.m_dLiPerp ;
   }
   if ( bSplitArcs) {
      if ( nType == MILL_LO_TANGENT)
         nType = MILL_LO_LINEAR ;
   }
  // eseguo a seconda del tipo
   switch ( nType) {
   case MILL_LO_NONE :
      ptP1 = ptEnd ;
      return true ;
   case MILL_LO_LINEAR :
      {
         if ( dTang < 10 * EPS_SMALL  &&  abs( dPerp) < EPS_SMALL)
            return false ;
         Vector3d vtPerp = vtEnd ;
         vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
         return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
      }
   case MILL_LO_TANGENT :
      {
        // calcolo punto finale dell'uscita
         if ( dTang < 10 * EPS_SMALL  &&  abs( dPerp) < EPS_SMALL)
            return false ;
         Vector3d vtPerp = vtEnd ;
         vtPerp.Rotate( vtN, ( ( m_Params.m_nWorkSide == MILL_WS_LEFT) ? 90 : - 90)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
        // inserisco uscita
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
         if ( IsNull( pCrv))
            return false ;
         if ( pCrv->GetType() == CRV_LINE) {
            ICurveLine* pLine = GetCurveLine( pCrv) ;
            Point3d ptP3 = pLine->GetEnd() ;
            return ( AddLinearMove( ptP3, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
         }
         else if ( pCrv->GetType() == CRV_ARC) {
            ICurveArc* pArc = GetCurveArc( pCrv) ;
            Point3d ptCen = pArc->GetCenter() ;
            double dAngCen = pArc->GetAngCenter() ;
            Vector3d vtN = pArc->GetNormVersor() ;
            Point3d ptP3 ;
            pArc->GetEndPoint( ptP3) ;
            // se angolo al centro minore del limite, un solo arco
            const double MAX_ANG_CEN = 150 + EPS_ANG_SMALL ;
            if ( abs( dAngCen) < MAX_ANG_CEN) {
               if ( AddArcMove( ptP3, ptCen, dAngCen, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
            }
            // altrimenti due archi
            else if ( abs( dAngCen) < 2 * MAX_ANG_CEN){
               Point3d ptMid ;
               pArc->GetMidPoint( ptMid) ;
              // prima metà arco
               if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
              // seconda metà arco
               ptCen.z = ptMid.z ;
               if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
            }
            // oppure tre archi
            else {
               Point3d ptTmp ;
              // primo terzo
               pArc->GetPointD1D2( 1. / 3, ICurve::FROM_MINUS, ptTmp) ;
               if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
              // secondo terzo
               ptCen.z = ptTmp.z ;
               pArc->GetPointD1D2( 2. / 3, ICurve::FROM_MINUS, ptTmp) ;
               if ( AddArcMove( ptTmp, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
              // ultimo terzo
               ptCen.z = ptTmp.z ;
               if ( AddArcMove( ptP3, ptCen, dAngCen / 3, vtN, MCH_CL_LEADOUT) == GDB_ID_NULL)
                  return false ;
            }
            return true ;
         }
      }
   case MILL_LO_GLIDE :
      // !!! DA FARE !!!
      return false ;
   default :
      return false ;
   }
}