//----------------------------------------------------------------------------
//  EgalTech 2018-2020
//----------------------------------------------------------------------------
// File : Mortising.cpp         Data : 18.02.20          Versione : 2.2b3
// Contenuto : Implementazione gestione mortasature.
//
//
//
// Modifiche : 25.02.18 DS Creazione modulo.
//             18.02.20 DS Aggiunta gestione MaxElev da NoteUtente.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MachMgr.h"
#include "DllMain.h"
#include "Mortising.h"
#include "OperationConst.h"
#include "OperUserNotesConst.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/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkUserObjFactory.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//------------------------------ Errors --------------------------------------
// 2501 = "Error in Mortising : UpdateToolData failed"
// 2502 = "Error in Mortising : Offset not computable"
// 2503 = "Error in Mortising : Empty RawBox"
// 2504 = "Error in Mortising : Depth not computable"
// 2505 = "Error in Mortising : Entity GetElevation"
// 2506 = "Error in Mortising : Chaining failed"
// 2507 = "Error in Mortising : axes values not calculable"
// 2508 = "Error in Mortising : outstroke xx"
// 2509 = "Error in Mortising : link movements not calculable"
// 2510 = "Error in Mortising : link outstroke xx"
// 2511 = "Error in Mortising : post apply not calculable"
// 2512 = "Error in Mortising : Tool MaxMaterial too small (xx)"
// 2513 = "Error in Mortising : Closed path not allowed"
// 2514 = "Error in Mortising : special apply not calculable"
// 2551 = "Warning in Mortising : Skipped entity (xx)"
// 2552 = "Warning in Mortising : Plunges not found"
// 2553 = "Warning in Mortising : Tool name changed (xx)"
// 2554 = "Warning in Mortising : Tool data changed (xx)"
// 2555 = "Warning in Mortising : skipped Path too short"
// 2556 = "Warning in Mortising : machining step too small (xx)"
// 2557 = "Warning in Mortising : machining step (xxx) bigger than MaxMaterial (yyy)"
// 2558 = "Warning in Mortising : machining depth (xxx) bigger than MaxMaterial (yyy)"

//----------------------------------------------------------------------------
USEROBJ_REGISTER( GetOperationClass( OPER_MORTISING), Mortising) ;

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

//----------------------------------------------------------------------------
Mortising*
Mortising::Clone( void) const
{
  // alloco oggetto
   Mortising* pMort = new(nothrow) Mortising ;
  // eseguo copia dei dati
   if ( pMort != nullptr) {
      try {
         pMort->m_vId = m_vId ;
         pMort->m_pMchMgr = m_pMchMgr ;
         pMort->m_nPhase = m_nPhase ;
         pMort->m_Params = m_Params ;
         pMort->m_TParams = m_TParams ;
         pMort->m_nStatus = m_nStatus ;
         pMort->m_nMortises = m_nMortises ;
      }
      catch( ...) {
         delete pMort ;
         return nullptr ;
      }
   }
  // ritorno l'oggetto
   return pMort ;
}

//----------------------------------------------------------------------------
bool
Mortising::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_nMortises) + szNewLine ;
   sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::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_nMortises, vString[++k]))
         return false ;
      if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
         return false ;
   }
   catch( ...) {
      return false ;
   }
   return true ;
}

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

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Mortising::Mortising( void)
{
   m_Params.m_sName = "*" ;
   m_Params.m_sToolName = "*" ;
   m_TParams.m_sName = "*" ;
   m_TParams.m_sHead = "*" ;
   m_nStatus = MCH_ST_TO_VERIFY ;
   m_nMortises = 0 ;
}

//----------------------------------------------------------------------------
bool
Mortising::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 MortisingData* pDdata = GetMortisingData( 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
Mortising::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case MPA_INVERT :
      if ( bVal != m_Params.m_bInvert)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bInvert = bVal ;
      return true ;
   case MPA_TOOLINVERT :
      if ( bVal != m_Params.m_bToolInvert)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_bToolInvert = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Mortising::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_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
Mortising::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_SPEED :
      if ( ! m_TParams.VerifySpeed( dVal))
         return false ;
      if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dSpeed = dVal ;
      return true ;
   case MPA_FEED :
      if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dFeed = dVal ;
      return true ;
   case MPA_STARTFEED :
      if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartFeed = dVal ;
      return true ;
   case MPA_ENDFEED :
      if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dEndFeed = dVal ;
      return true ;
   case MPA_TIPFEED :
      if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
         dVal = 0 ;
      if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dTipFeed = dVal ;
      return true ;
   case MPA_OFFSR :
      if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
         dVal = UNKNOWN_PAR ;
      if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOffsR = dVal ;
      return true ;
   case MPA_OFFSL :
      if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
         dVal = UNKNOWN_PAR ;
      if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dOffsL = dVal ;
      return true ;
   case MPA_DEPTH: {
      string sVal = ToString( dVal) ;
      if ( sVal != m_Params.m_sDepth)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sDepth = sVal ;
      } return true ;
   case MPA_STARTPOS :
      if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStartPos = dVal ;
      return true ;
   case MPA_STEP :
      if ( abs( dVal - m_Params.m_dStep) > EPS_MACH_LEN_PAR)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_dStep = dVal ;
      return true ;
   case MPA_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 ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Mortising::SetParam( int nType, const string& sVal)
{
   switch ( nType) {
   case MPA_TOOL : {
      const ToolData* pTdata ;
      if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
         return false ;
      if ( ! SameTool( m_TParams, *pTdata))
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sToolName = sVal ;
      m_Params.m_ToolUuid = pTdata->m_Uuid ;
      m_TParams = *pTdata ;
      } return true ;
   case MPA_DEPTH_STR :
      if ( sVal != m_Params.m_sDepth)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sDepth = sVal ;
      return true ;
   case MPA_SYSNOTES :
      if ( sVal != m_Params.m_sSysNotes)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sSysNotes = sVal ;
      return true ;
   case MPA_USERNOTES :
      if ( sVal != m_Params.m_sUserNotes)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sUserNotes = sVal ;
      return true ;
   case MPA_INITANGS :
      if ( sVal != m_Params.m_sInitAngs)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sInitAngs = sVal ;
      return true ;
   case MPA_BLOCKEDAXIS :
      if ( sVal != m_Params.m_sBlockedAxis)
         m_nStatus |= MCH_ST_PARAM_MODIF ;
      m_Params.m_sBlockedAxis = sVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
Mortising::SetGeometry( const SELVECTOR& vIds)
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // copia temporanea e reset della geometria corrente
   SELVECTOR vOldId = m_vId ;
   m_vId.clear() ;
  // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
   int nType = GEO_NONE ;
   for ( const auto& Id : vIds) {
     // test sull'entità
      int nSubs ;
      if ( ! VerifyGeometry( Id, nSubs, nType)) {
         string sInfo = "Warning in Mortising : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2551, 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
Mortising::Preview( bool bRecalc)
{
  // reset numero percorsi di lavoro generati
   m_nMortises = 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( 2501, "Error in Mortising : UpdateToolData failed") ;
      return false ;
   }

  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
   if ( bChain  &&  ! Chain( nAuxId)) {
      m_pMchMgr->SetLastError( 2506, "Error in Mortising : 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
Mortising::Apply( bool bRecalc, bool bPostApply)
{
  // reset numero mortasature generate
   int nCurrMortises = m_nMortises ;
   m_nMortises = 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( 2501, "Error in Mortising : UpdateToolData failed") ;
      return false ;
   }

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

  // verifico se necessario continuare nell'aggiornamento
   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
     // confermo i percorsi di lavorazione
      m_nMortises = nCurrMortises ;
      string sLog = string( "Mortising 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) ;
   }

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

  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
   if ( bChain) {
      if ( ! Chain( nAuxId)) {
         m_pMchMgr->SetLastError( 2506, "Error in Mortising : 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) ;

  // 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(), "Mortising apply done") ;

   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::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_nMortises == 0) {
      m_pMchMgr->SetWarning( 2552, "Warning in Mortising : Plunges not found") ;
      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, true)) {
      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
      if ( sInfo.empty())
         m_pMchMgr->SetLastError( 2507, "Error in Mortising : axes values not calculable") ;
      else
         m_pMchMgr->SetLastError( 2508, "Error in Mortising : outstroke ") ;
      return false ;
   }

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

  // esecuzione eventuali personalizzazioni speciali
   string sSpecErr ;
   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
      if ( ! IsEmptyOrSpaces( sSpecErr))
         m_pMchMgr->SetLastError( 2514, sSpecErr) ;
      else
         m_pMchMgr->SetLastError( 2514, "Error in Mortising : special apply not calculable") ;
      return false ;
   }

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

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

   return true ;
}

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

//----------------------------------------------------------------------------
bool
Mortising::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_MORTISING ;
      return true ;
   case MPA_WORKSIDE :
      nVal = m_Params.m_nWorkSide ;
      return true ;
   case MPA_STEPTYPE :
      nVal = m_Params.m_nStepType ;
      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
Mortising::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case MPA_SPEED :
      dVal = GetSpeed() ;
      return true ;
   case MPA_FEED :
      dVal = GetFeed() ;
      return true ;
   case MPA_STARTFEED :
      dVal = GetStartFeed() ;
      return true ;
   case MPA_ENDFEED :
      dVal = GetEndFeed() ;
      return true ;
   case MPA_TIPFEED :
      dVal = GetTipFeed() ;
      return true ;
   case MPA_OFFSR :
      dVal = GetOffsR() ;
      return true ;
   case MPA_OFFSL :
      dVal = GetOffsL() ;
      return true ;
   case MPA_STARTPOS :
      dVal = m_Params.m_dStartPos ;
      return true ;
   case MPA_STEP :
      dVal = m_Params.m_dStep ;
      return true ;
   case MPA_STARTADDLEN :
      dVal = m_Params.m_dStartAddLen ;
      return true ;
   case MPA_ENDADDLEN :
      dVal = m_Params.m_dEndAddLen ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

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

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

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

//----------------------------------------------------------------------------
bool
Mortising::VerifyGeometry( SelData Id, int& nSubs, int& nType)
{
  // ammessi : tutte curve o tutte facce di trimesh
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   if ( pGObj == nullptr)
      return false ;
  // se ammesse curve ed è tale
   if ( nType != GEO_SURF  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
      const ICurve* pCurve = nullptr ;
      // se direttamente la curva
      if ( Id.nSub == SEL_SUB_ALL) {
         pCurve = ::GetCurve( pGObj) ;
         if ( pCurve != nullptr) {
            if ( pCurve->GetType() == CRV_COMPO)
               nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
            else
               nSubs = 0 ;
         }
      }
      // altrimenti sottocurva di composita
      else {
         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
         if ( pCompo != nullptr)
            pCurve = pCompo->GetCurve( Id.nSub) ;
         nSubs = 0 ;
      }
      return ( pCurve != nullptr) ;
   }
  // se altrimenti ammesse superfici trimesh ed è tale
   else if ( nType != GEO_CURVE  &&  ( pGObj->GetType() & GEO_SURF) != 0) {
      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
      if ( pSurf == nullptr)
         return false ;
      // se direttamente la superficie
      if ( Id.nSub == SEL_SUB_ALL) {
         nSubs = pSurf->GetFacetCount() ;
         return true ;
      }
      // altrimenti faccia di superficie trimesh
      else {
        // se faccia non esistente
         if ( Id.nSub > pSurf->GetFacetCount())
            return false ;
        // tutto bene
         nSubs = 0 ;
         return true ;
      }
   }
  // altrimenti errore
   else
      return false ;
}

//----------------------------------------------------------------------------
ICurve*
Mortising::GetCurve( SelData Id)
{
  // ammessi : curve o facce di polymesh
   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
   if ( pGObj == nullptr)
      return nullptr ;
  // ne recupero il riferimento globale
   Frame3d frGlob ;
   if ( ! m_pGeomDB->GetGlobFrame( Id.nId, frGlob))
      return nullptr ;
  // se curva
   if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
      PtrOwner<ICurve> pCurve ;
      // se direttamente curva
      if ( Id.nSub == SEL_SUB_ALL) {
        // recupero e duplico la curva
         const ICurve* pOriCurve = ::GetCurve( pGObj) ;
         if ( pOriCurve != nullptr)
            pCurve.Set( pOriCurve->Clone()) ;
        // 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) {
           // 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)  ||  vtExtr.IsSmall())
                  vtExtr = Z_AX ;
               pCurve->SetExtrusion( vtExtr) ;
               double dThick ;
               if ( pCompo->GetThickness( dThick))
                  pCurve->SetThickness( dThick) ;
            }
         }
      }
      if ( IsNull( pCurve))
         return nullptr ;
     // la porto in globale
      pCurve->ToGlob( frGlob) ;
     // la restituisco
      return Release( pCurve) ;
   }
  // se altrimenti superficie
   else if ( ( pGObj->GetType() & GEO_SURF) != 0) {
     // recupero la trimesh 
      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
      if ( pSurf == nullptr)
         return nullptr ;
     // 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 nullptr ;
     // recupero la normale esterna della faccia
      Vector3d vtN ;
      if ( ! pSurf->GetFacetNormal( nFacet, vtN))
         return nullptr ;
     // creo la curva a partire da quello esterno
      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
      pCrvCompo->FromPolyLine( vPL[0]) ;
      if ( ! pCrvCompo->IsValid())
         return nullptr ;
     // 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_PAR_SLANT ;
      int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
      AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, V_NULL, {}, m_TParams.m_dThick, 2) ;
     // la restituisco
      return Release( pCrvCompo) ;
   }
  // altrimenti errore
   else
      return nullptr ;
}

//----------------------------------------------------------------------------
bool
Mortising::Chain( int nGrpDestId)
{
  // vettore puntatori alle curve
   ICURVEPOVECTOR 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 sInfo = "Warning in Mortising : Skipped entity " + ToString( Id) ;
         m_pMchMgr->SetWarning( 2551, sInfo) ;
         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)  &&  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) ; 
     // 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
Mortising::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
Mortising::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)) ;

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

  // recupero estrusione e spessore
   Vector3d vtExtr = Z_AX ;
   pCompo->GetExtrusion( vtExtr) ;
   double dThick ;
   pCompo->GetThickness( dThick) ;
  // se molto vicina alla direzione Z+ la approssimo con questa (per compensare piccoli errori e limiti macchine)
   const double MAX_APPROX_DIR = cos( 0.2 * DEGTORAD) ;
   if ( vtExtr * Z_AX > MAX_APPROX_DIR)
      vtExtr = Z_AX ;

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

  // verifico non sia un percorso chiuso
   if ( pCompo->IsClosed()) {
      m_pMchMgr->SetLastError( 2513, "Error in Mortising : Closed path not allowed") ;
      return false ;
   }

  // eventuali allungamenti/accorciamenti
   {
     // inclinazione della direzione utensile rispetto al movimento
      Vector3d vtTg ; pCompo->GetMidDir( vtTg) ;
      double dSinAng = max( ( vtTg ^ vtExtr).Len(), sin( 30 * DEGTORAD)) ;
      double dStartAddLen = m_Params.m_dStartAddLen / dSinAng ;
      double dEndAddLen = m_Params.m_dEndAddLen / dSinAng ;
     // verifico che il percorso sia abbastanza lungo
      double dLen ; pCompo->GetLength( dLen) ;
      if ( dLen + dStartAddLen + dEndAddLen < 10 * EPS_SMALL) {
         m_pMchMgr->SetWarning( 2555, "Warning in Mortising : 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 ( dStartAddLen > EPS_SMALL) {
         if ( ! pCompo->ExtendStartByLen( dStartAddLen))
            return false ;
         dLen += dStartAddLen ;
      }
      if (dEndAddLen > EPS_SMALL) {
         if ( ! pCompo->ExtendEndByLen( dEndAddLen))
            return false ;
         dLen += dEndAddLen ;
      }
     // eventuale accorciamenti (da fare dopo tutti gli allungamenti)
      if ( dStartAddLen < - EPS_SMALL) {
         if ( ! pCompo->TrimStartAtLen( -dStartAddLen))
            return false ;
         dLen += dStartAddLen ;
      }
      if ( dEndAddLen < - EPS_SMALL) {
         if ( ! pCompo->TrimEndAtLen( dLen + dEndAddLen))
            return false ;
         dLen += dEndAddLen ;
      }
   }

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

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

  // determino il versore ausiliario
   Vector3d vtAux = ( ptEnd - ptStart) ^ vtExtr ;
   vtAux.Normalize() ;
   if ( vtAux.z < -EPS_ZERO)
      vtAux.Invert() ;

  // sistemo per lato di lavoro e offset radiale
   Vector3d vtSide = ( ptEnd - ptStart) ^ vtExtr ;
   vtSide.Normalize() ;
   if ( m_Params.m_nWorkSide == MORTISE_WS_LEFT)
      vtSide.Invert() ;
   if ( AreOppositeVectorApprox( vtAux, vtSide))
      pCompo->Translate( vtSide * m_TParams.m_dThick) ;
   if ( abs( GetOffsR()) > EPS_SMALL)
      pCompo->Translate( vtSide * GetOffsR()) ;

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

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

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

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

  // assegno il versore fresa
   Vector3d vtTool = vtExtr ;

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

  // ingombro aggiuntivo da larghezza sega a catena quando inclinata rispetto al movimento
   Vector3d vtTg ; pCompo->GetMidDir( vtTg) ;
   double dSinAng = max( ( vtTg ^ vtExtr).Len(), sin( 30 * DEGTORAD)) ;
   double dCosAng = min( abs( vtTg * vtExtr), cos( 30 * DEGTORAD)) ;
   double dAddEnc = m_TParams.m_dDiam / 2 * dCosAng / dSinAng ;

  // affondamento speciale da note utente (!!! da trasformare in parametro come gli altri !!!)
   int nPlunge = 0 ;
   GetValInNotes( m_Params.m_sUserNotes, UN_PLUNGE, nPlunge) ;

  // verifico che lo step dell'utensile sia sensato
   double dOkStep = ( nPlunge == MORTISE_PLUNGE_STEP  ||  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ ? m_Params.m_dStep : 0) ;
   const double MIN_ZSTEP = 1.0 ;
   if ( dOkStep >= EPS_SMALL  &&  dOkStep < MIN_ZSTEP) {
      dOkStep = MIN_ZSTEP ;
      string sInfo = "Warning in Mortising : machining step too small (" +
                     ToString( m_Params.m_dStep, 2) + ")" ;
      m_pMchMgr->SetWarning( 2556, 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 Mortising : Tool MaxMaterial too small (" +
                     ToString( m_TParams.m_dMaxMat, 2) + ")" ;
      m_pMchMgr->SetLastError( 2512, sInfo) ;
      return false ;
   }

  // se lo step supera la capacità dell'utensile
   if ( dOkStep > m_TParams.m_dMaxMat + EPS_SMALL) {
      dOkStep = m_TParams.m_dMaxMat ;
      string sInfo = "Warning in Mortising : machining step (" + ToString( m_Params.m_dStep, 1) +
                     ") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
      m_pMchMgr->SetWarning( 2557, sInfo) ;
   }
  // massimo affondamento dell'utensile
   double dMaxDepth = m_TParams.m_dMaxMat - dAddEnc ;
  // se l'elevazione supera il massimo affondamento dell'utensile
   if ( dElev > dMaxDepth + EPS_SMALL) {
     // segnalo, riduco e continuo
      string sInfo = "Warning in Mortising : machining depth (" + ToString( dElev, 1) +
                     ") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
      m_pMchMgr->SetWarning( 2558, sInfo) ;
      dDepth -= dElev - dMaxDepth ;
      dElev = dMaxDepth ;
   }  

  // 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) ;
     // creo l'anteprima del percorso
      if ( ! GenerateMortisingPv( nPxId, pCompo))
         return false ;
   }

  // se richiesta lavorazione
   if ( nClId != GDB_ID_NULL) {
     // creo gruppo per geometria di lavorazione del percorso
      int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
      if ( nPxId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nPxId, sPathName) ;
      m_pGeomDB->SetMaterial( nPxId, BLUE) ;

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

     // Calcolo la mortasatura   
      if ( ! GenerateMortisingCl( pCompo, vtTool, dDepth, dElev, dOkStep, nPlunge))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dThick,
                              double& dElev) const
{
   dElev = 0 ;
   int nMaxInd = pCompo->GetCurveCount() - 1 ;
   for ( int i = 0 ; i <= nMaxInd ; ++ i) {
     // curva corrente
      const ICurve* pCrvC = pCompo->GetCurve( i) ;
     // calcolo elevazione
      double dCurrElev ;
      Point3d ptStart, ptMid, ptEnd ;
      pCrvC->GetStartPoint( ptStart) ;
      pCrvC->GetMidPoint( ptMid) ;
      pCrvC->GetEndPoint( ptEnd) ;
      Vector3d vtStartPerp, vtEndPerp ;
      pCrvC->GetStartDir( vtStartPerp) ;
      vtStartPerp *= -dRad ;
      pCrvC->GetEndDir( vtEndPerp) ;
      vtEndPerp *= dRad ;
      Vector3d vtTg ; pCrvC->GetMidDir( vtTg) ;
      Vector3d vtOrtho = vtTool ^ vtTg ;
      vtOrtho.Normalize() ;
      vtOrtho *= dThick ;
      Vector3d vtDepth = -vtTool * dDepth ;
      // linea centro utensile
      if ( GetElevation( m_nPhase, ptStart + vtDepth, ptMid + vtDepth, ptEnd + vtDepth, vtTool, dCurrElev)) {
         if ( dCurrElev > dElev)
            dElev = dCurrElev ;
      }
      else {
         m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
         return false ;
      }
      // sopra centro utensile
      if ( GetElevation( m_nPhase, ptStart + vtDepth + vtOrtho, ptMid + vtDepth + vtOrtho, ptEnd + vtDepth + vtOrtho, vtTool, dCurrElev)) {
         if ( dCurrElev > dElev)
            dElev = dCurrElev ;
      }
      else {
         m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
         return false ;
      }
      // da una parte
      if ( GetElevation( m_nPhase, ptStart + vtStartPerp + vtDepth, ptMid + vtDepth,
                                   ptEnd + vtEndPerp + vtDepth, vtTool, dCurrElev)) {
         if ( dCurrElev > dElev)
            dElev = dCurrElev ;
      }
      else {
         m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
         return false ;
      }
      // dall'altra parte
      if ( GetElevation( m_nPhase, ptStart + vtStartPerp + vtDepth, ptMid + vtDepth,
                                   ptEnd + vtEndPerp + vtDepth, vtTool, dCurrElev)) {
         if ( dCurrElev > dElev)
            dElev = dCurrElev ;
      }
      else {
         m_pMchMgr->SetLastError( 2505, "Error in Mortising : Entity GetElevation") ;
         return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::GenerateMortisingPv( int nPathId, const ICurveComposite* pCompo)
{
  // incremento numero di mortasature
   ++ m_nMortises ;
   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& vtTool,
                                double dDepth, double dElev, double dOkStep, int nPlunge)
{
  // inizio e fine
   Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
   Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;

  // verifico se affondamento ripetuto è veramente tale
   if ( ( nPlunge == MORTISE_PLUNGE_START_END  ||  nPlunge == MORTISE_PLUNGE_START_TO_END)  &&  Dist( ptStart, ptEnd) < 10 * EPS_SMALL)
      nPlunge = MORTISE_PLUNGE_START ;

  // se affondamento inizio e fine
   if ( nPlunge == MORTISE_PLUNGE_START_END) {
     // affondamento iniziale
      if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_START, true))
         return false ;      
     // affondamento finale
      if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_END, false))
         return false ;      
   }

  // se alrimenti affondamenti ripetuti da inizio a fine con ritorno basso
   else if ( nPlunge == MORTISE_PLUNGE_START_TO_END) {
     // distanza e vettore spostamento laterale
      Vector3d vtDir = ptEnd - ptStart ;
      double dLen = vtDir.Len() ;
      vtDir.Normalize() ;
     // affondamenti iniziale e intermedi
      int kMax = ( int) floor( dLen / m_TParams.m_dDiam) ;
      for ( int k = 0 ; k <= kMax ; ++ k) {
         Point3d ptNewStart = ptStart + vtDir * k * m_TParams.m_dDiam ;
        // se non è finale 
         if ( k != kMax  ||  ! AreSamePointEpsilon( ptNewStart, ptEnd, 10 * EPS_SMALL)) {
            if ( ! GenerateOnePlungeCl( ptNewStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_START, k == 0))
               return false ;         
         }          
      }
     // affondamento finale
      if ( ! GenerateOnePlungeCl( ptEnd, ptStart, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_STEP, false))
         return false ;      
   }
 
  // altrimenti affondamento singolo
   else {
      if ( ! GenerateOnePlungeCl( ptStart, ptEnd, vtTool, dDepth, dElev, dOkStep, nPlunge, true))
         return false ;
   }

  // reset dati di movimento
   ResetMoveData() ;
  // incremento numero di mortasature
   ++ m_nMortises ;
      
   return true ;
}

//----------------------------------------------------------------------------
bool
Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, double dDepth, double dElev, 
                                double dOkStep, int nPlunge, bool bFirst)
{
  // compensazione elevazione/affondamento
   double dDelta = dElev - dDepth ;
  // pre-calcolo step per modalità con step
   int nStep = 1 ;
   double dStep = dElev ;
   if ( nPlunge == MORTISE_PLUNGE_STEP  ||  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
      if ( dOkStep < EPS_SMALL)
         dOkStep = dElev ;
      nStep = max( 1, static_cast<int>( ceil( ( dElev - 10 * EPS_SMALL) / dOkStep))) ;
      dStep = dElev / nStep ;
   }

  // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
   double dSafeZ = GetSafeZ() + GetDeltaSafeZ( vtTool) ;
   double dStartElev = 0 ;
   Point3d ptLi = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * dDelta ;
   bool bUnderStart = GetAhPointUnderRaw( ptLi, vtTool, 0,
                                          GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dStartElev) ;
  // altrimenti ridetermino elevazione su inizio percorso di lavoro
   if ( ! bUnderStart)
      GetElevation( m_nPhase, ptLi, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartElev) ;

  // sicurezza su punto iniziale
   double dAppr = dStartElev + dSafeZ ;
   if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
      double dStartDownElev ;
      if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartDownElev))
         dStartDownElev = dDelta ;
      if ( dStartDownElev < EPS_SMALL)
         dAppr = -dStep ;
   }

  // 1 -> punto approccio
   int nFirstFlag = ( bFirst ? 1 : 0) ; 
   SetFlag( nFirstFlag) ;
   Point3d ptP1 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + dAppr) ;
   if ( AddRapidStartOrMove( ptP1, bFirst) == GDB_ID_NULL)
      return false ;
   SetFlag( 0) ;

  // 2 -> punto fuori (se diverso dal precedente)
   if ( m_Params.m_dStartPos < dAppr - 10 * EPS_SMALL) {
      Point3d ptP2 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + m_Params.m_dStartPos) ;
      if ( AddRapidMove( ptP2) == GDB_ID_NULL)
         return false ;
   }

  // eseguo ciclo a seconda del tipo di affondamento
   Point3d ptLast ;
   if ( nPlunge == MORTISE_PLUNGE_START) {
     // 3 -> punto in affondamento
      SetFeed( GetStartFeed()) ;
      SetFlag( 0) ;
      Point3d ptP3 = ptStart + ( dDelta - dElev) * vtTool ;
      if ( AddLinearMove( ptP3) == GDB_ID_NULL)
         return false ;
      ptLast = ptStart ;
   }
   else if ( nPlunge == MORTISE_PLUNGE_END) {
     // 3 -> punto in affondamento
      SetFeed( GetStartFeed()) ;
      SetFlag( 0) ;
      Point3d ptP3 = ptEnd + ( dDelta - dElev) * vtTool ;
      if ( AddLinearMove( ptP3) == GDB_ID_NULL)
         return false ;
      ptLast = ptEnd ;
   }
   else {
     // determino numero e affondamento degli step
      const double RETURN_DIST = 10 ;
     // a seconda del tipo
      switch ( m_Params.m_nStepType) {
      default :    // ZIGZAG
         for ( int i = 1 ; i <= nStep ; ++ i) {
           // 3 -> punto in affondamento
            SetFeed( GetStartFeed()) ;
            SetFlag( 0) ;
            Point3d ptP3 = (( i % 2 == 1) ? ptStart : ptEnd) + ( dDelta - i * dStep) * vtTool ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL  &&  ! ( i == 1  &&  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ))
               return false ;
           // 4 -> punto termine
            SetFeed( GetFeed()) ;
            SetFlag( 0) ;
            ptLast = (( i % 2 == 1) ? ptEnd : ptStart) ;
            Point3d ptP4 = ptLast + ( dDelta - i * dStep) * vtTool ;
            if ( AddLinearMove( ptP4) == GDB_ID_NULL)
               return false ;
         }
         break ;
      case MORTISE_ST_ONEWAY :
         for ( int i = 1 ; i <= nStep ; ++ i) {
           // 3 -> punto in affondamento
            SetFeed( GetStartFeed()) ;
            SetFlag( 0) ;
            Point3d ptP3 = ptStart + ( dDelta - i * dStep) * vtTool ;
            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
               return false ;
           // 4 -> punto termine
            SetFeed( GetFeed()) ;
            SetFlag( 0) ;
            ptLast = ptEnd ;
            Point3d ptP4 = ptLast + ( dDelta - i * dStep) * vtTool ;
            if ( AddLinearMove( ptP4) == GDB_ID_NULL)
               return false ;
           // 5 -> ritorno sull'inizio, se non ultimo punto
            if ( i < nStep) {
              // retrocedo
               SetFeed( GetFeed()) ;
               SetFlag( 0) ;
               Point3d ptP5a = ptP4 + RETURN_DIST * vtTool ;
               if ( AddLinearMove( ptP5a) == GDB_ID_NULL)
                  return false ;
              // ritorno sopra inizio
               SetFeed( GetFeed()) ;
               SetFlag( 0) ;
               Point3d ptP5b = ptP3 + RETURN_DIST * vtTool ;
               if ( AddLinearMove( ptP5b) == GDB_ID_NULL)
                  return false ;
            }
         }
         break ;
      }
   }

  // determino se la fine dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
   double dEndElev = 0 ;
   Point3d ptLo = ptLast + vtTool * dDelta ;
   bool bUnderEnd = GetAhPointUnderRaw( ptLo, vtTool, 0,
                                        GetRadiusForStartEndElevation(), m_TParams.m_dLen, false, dSafeZ, vtTool, dEndElev) ;
  // altrimenti ridetermino elevazione su fine percorso di lavoro
   if ( ! bUnderEnd)
      GetElevation( m_nPhase, ptLo, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev) ;

  // sicurezza su punto finale
   double dRetr = dEndElev + dSafeZ ;
   if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
      double dEndDownElev ;
      if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndDownElev))
         dEndDownElev = dDelta ;
      if ( dEndDownElev < EPS_SMALL)
         dRetr = dEndElev - dStep ;
   }
   
  // 6 -> ritorno all'approccio
   SetFeed( GetEndFeed()) ;
   SetFlag( 104) ;            // risalita sopra la fine
   Point3d ptP6 = ptLast + vtTool * ( dDelta + dRetr) ;
   if ( AddLinearMove( ptP6) == GDB_ID_NULL)
      return false ;

   return true ;
}

//----------------------------------------------------------------------------
double
Mortising::GetRadiusForStartEndElevation( void) const
{
   const double DELTA_ELEV_RAD = 20.0 ; 
   return ( 0.5 * m_TParams.m_dTDiam + DELTA_ELEV_RAD) ;
}