EgtMachKernel 2.3k2 :

- nella gestione link tra lavorazioni aggiunta possibilità di utilizzo script OnSpecialGetMaxZ che determina la Zmassima raggiungibile nel collegamento in funzione delle posizioni testa iniziale e finale.
2021-11-22 11:10:03 +01:00
parent cfb2fea0bd
commit 17c7be3a56
4 changed files with 429 additions and 233 deletions
@@ -1111,34 +1111,19 @@ Operation::CalcAndSetAxesBBox( void)
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 bool
-Operation::GetInitialAxesValues( DBLVECTOR& vAxVal) const
+Operation::GetInitialAxesValues( bool bSkipClimb, DBLVECTOR& vAxVal) const
 {
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
-  // recupero gruppo per geometria di lavorazione (Cutter Location)
-   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
-   if ( nClId == GDB_ID_NULL)
-      return false ;
-  // recupero il primo percorso CL
-   int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
-  // restituisco i valori iniziali degli assi di questo percorso di lavorazione
-   return GetClPathInitialAxesValues( nClPathId, vAxVal) ;
+   const CamData* pCamData = GetInitialCamData( bSkipClimb) ;
+   vAxVal = ( pCamData != nullptr ? pCamData->GetAxesVal() : DBLVECTOR()) ;
+   return ( vAxVal.size() > 0) ;
 }

 //----------------------------------------------------------------------------
 bool
-Operation::GetClPathInitialAxesValues( int nClPathId, DBLVECTOR& vAxVal) const
+Operation::GetClPathInitialAxesValues( int nClPathId, bool bSkipClimb, DBLVECTOR& vAxVal) const
 {
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
-  // recupero la prima entità di questo percorso
-   int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
-  // recupero i dati Cam dell'entità
-   CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
-   if ( pCamData == nullptr)
-      return false ;
-  // assegno i valori degli assi
-   vAxVal = pCamData->GetAxesVal() ;
+   const CamData* pCamData = GetClPathInitialCamData( nClPathId, bSkipClimb) ;
+   vAxVal = ( pCamData != nullptr ? pCamData->GetAxesVal() : DBLVECTOR()) ;
   return ( vAxVal.size() > 0) ;
 }

@@ -1146,24 +1131,115 @@ Operation::GetClPathInitialAxesValues( int nClPathId, DBLVECTOR& vAxVal) const
 bool
 Operation::GetFinalAxesValues( bool bSkipRise, DBLVECTOR& vAxVal) const
 {
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
-  // recupero gruppo per geometria di lavorazione (Cutter Location)
-   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
-   if ( nClId == GDB_ID_NULL)
-      return false ;
-  // recupero l'ultimo percorso CL
-   int nClPathId = m_pGeomDB->GetLastGroupInGroup( nClId) ;
-  // restituisco i valori finali degli assi di questo percorso di lavorazione
-   return GetClPathFinalAxesValues( nClPathId, bSkipRise, vAxVal) ;
+   const CamData* pCamData = GetFinalCamData( bSkipRise) ;
+   vAxVal = ( pCamData != nullptr ? pCamData->GetAxesVal() : DBLVECTOR()) ;
+   return ( vAxVal.size() > 0) ;
 }

 //----------------------------------------------------------------------------
 bool
 Operation::GetClPathFinalAxesValues( int nClPathId, bool bSkipRise, DBLVECTOR& vAxVal) const
+{
+   const CamData* pCamData = GetClPathFinalCamData( nClPathId, bSkipRise) ;
+   vAxVal = ( pCamData != nullptr ? pCamData->GetAxesVal() : DBLVECTOR()) ;
+   return ( vAxVal.size() > 0) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetInitialToolDir( bool bSkipClimb, Vector3d& vtTool) const
+{
+   const CamData* pCamData = GetInitialCamData( bSkipClimb) ;
+   vtTool = ( pCamData != nullptr ? pCamData->GetToolDir() : V_NULL) ;
+   return ( ! vtTool.IsSmall()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetClPathInitialToolDir( int nClPathId, bool bSkipClimb, Vector3d& vtTool) const
+{
+   const CamData* pCamData = GetClPathInitialCamData( nClPathId, bSkipClimb) ;
+   vtTool = ( pCamData != nullptr ? pCamData->GetToolDir() : V_NULL) ;
+   return ( ! vtTool.IsSmall()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetFinalToolDir( bool bSkipRise, Vector3d& vtTool) const
+{
+   const CamData* pCamData = GetFinalCamData( bSkipRise) ;
+   vtTool = ( pCamData != nullptr ? pCamData->GetToolDir() : V_NULL) ;
+   return ( ! vtTool.IsSmall()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetClPathFinalToolDir( int nClPathId, bool bSkipRise, Vector3d& vtTool) const
+{
+   const CamData* pCamData = GetClPathFinalCamData( nClPathId, bSkipRise) ;
+   vtTool = ( pCamData != nullptr ? pCamData->GetToolDir() : V_NULL) ;
+   return ( ! vtTool.IsSmall()) ;
+}
+
+//----------------------------------------------------------------------------
+const CamData*
+Operation::GetInitialCamData( bool bSkipClimb) const
 {
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
+      return nullptr ;
+  // recupero gruppo per geometria di lavorazione (Cutter Location)
+   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
+   if ( nClId == GDB_ID_NULL)
+      return nullptr ;
+  // recupero il primo percorso CL
+   int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
+  // recupero i dati Cam della prima entità del percorso
+   return GetClPathInitialCamData( nClPathId, bSkipClimb) ;
+}
+
+//----------------------------------------------------------------------------
+const CamData*
+Operation::GetClPathInitialCamData( int nClPathId, bool bSkipClimb) const
+{
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return nullptr ;
+  // recupero la prima entità di questo percorso
+   int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
+  // se richiesto di ignorare le entità CLIMB
+   if ( bSkipClimb) {
+      while ( nEntId != GDB_ID_NULL) {
+         string sName ;
+         if ( ! m_pGeomDB->GetName( nEntId, sName)  ||  sName != MCH_CL_CLIMB)
+            break ;
+         nEntId = m_pGeomDB->GetNext( nEntId) ;
+      }
+   }
+  // recupero i dati Cam dell'entità
+   return GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
+}
+
+//----------------------------------------------------------------------------
+const CamData*
+Operation::GetFinalCamData( bool bSkipRise) const
+{
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return nullptr ;
+  // recupero gruppo per geometria di lavorazione (Cutter Location)
+   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
+   if ( nClId == GDB_ID_NULL)
+      return nullptr ;
+  // recupero l'ultimo percorso CL
+   int nClPathId = m_pGeomDB->GetLastGroupInGroup( nClId) ;
+  // recupero i dati Cam dell'ultima entità del percorso
+   return GetClPathFinalCamData( nClPathId, bSkipRise) ;
+}
+
+//----------------------------------------------------------------------------
+const CamData*
+Operation::GetClPathFinalCamData( int nClPathId, bool bSkipRise) const
+{
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return nullptr ;
  // recupero l'ultima entità di questo percorso
   int nEntId = m_pGeomDB->GetLastInGroup( nClPathId) ;
  // se richiesto di ignorare le entità RISE
@@ -1176,12 +1252,7 @@ Operation::GetClPathFinalAxesValues( int nClPathId, bool bSkipRise, DBLVECTOR& v
      }
   }
  // recupero i dati Cam dell'entità
-   CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
-   if ( pCamData == nullptr)
-      return false ;
-  // assegno i valori degli assi
-   vAxVal = pCamData->GetAxesVal() ;
-   return ( vAxVal.size() > 0) ;
+   return GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
 }

 //----------------------------------------------------------------------------
@@ -1792,16 +1863,20 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
      if ( bVerifyPreviousLink) {
        // recupero se ZHome è in basso
         bool bZHomeDown = GetZHomeDown() ;
+        // recupero quota di home in Z
+         double dHomeZ ;
+         if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ))
+            return false ;
        // elimino eventuali CLIMB già presenti
         RemoveClimb( m_pGeomDB->GetFirstGroupInGroup( nClId)) ;
        // recupero posizione iniziale lavorazione
         DBLVECTOR vAxIni ;
-         if ( ! GetInitialAxesValues( vAxIni))
+         if ( ! GetInitialAxesValues( false, vAxIni))
            return false ;
        // se necessaria, aggiungo risalita parziale
         double dDeltaZ = ( vAxIni[2] - vAxVal[2]) ;
-         if ( ( ! bZHomeDown  &&  dDeltaZ > 100 * EPS_SMALL)  ||
-              ( bZHomeDown  &&  dDeltaZ < -100 * EPS_SMALL)) {
+         if ( ( ! bZHomeDown  &&  dDeltaZ > 100 * EPS_SMALL  &&  vAxIni[2] <= dHomeZ)  ||
+              ( bZHomeDown  &&  dDeltaZ < -100 * EPS_SMALL  &&  vAxIni[2] >= dHomeZ)) {
            if ( ! pPrevOp->AddRise( vAxVal, dDeltaZ, GDB_ID_NULL, bZHomeDown))
               return false ;
           // aggiorno quota in Z della posizione iniziale ( anche se verrà aggiornata solo in seguito)
@@ -1809,51 +1884,49 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
         }
        // Verifico non ci sia collisione a HomeZ
         bool bToZmax = false ;
-         double dHomeZ ;
-         if ( m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ)) {
-            DBLVECTOR vAxVal2 = vAxVal ; vAxVal2[2] = dHomeZ ;
-            DBLVECTOR vAxIni2 = vAxIni ; vAxIni2[2] = dHomeZ ;
-            if ( ! TestCollisionAvoid( vAxVal2, vAxIni2)) {
-              // se ammessa risalita aggiuntiva
-               double dExtraZ, dMaxAngV ;
-               if ( GetExtraZ( dHomeZ, dExtraZ, dMaxAngV)) {
-                  if ( vAxVal2.size() < 5  ||  ( abs( vAxVal2[4]) < dMaxAngV  &&  abs( vAxIni2[4]) < dMaxAngV)) {
-                     double dMyHomeZ = dHomeZ + dExtraZ ;
-                     vAxVal2[2] = dMyHomeZ ;
-                     vAxIni2[2] = dMyHomeZ ;
-                     if ( TestCollisionAvoid( vAxVal2, vAxIni2))
-                        dHomeZ = dMyHomeZ ;
-                     else
-                        bToZmax = true ;
-                  }
+         DBLVECTOR vAxVal2 = vAxVal ; vAxVal2[2] = dHomeZ ;
+         DBLVECTOR vAxIni2 = vAxIni ; vAxIni2[2] = dHomeZ ;
+         if ( ! TestCollisionAvoid( vAxVal2, vAxIni2)) {
+           // se ammessa risalita aggiuntiva
+            Vector3d vtTprev ; pPrevOp->GetFinalToolDir( false, vtTprev) ;
+            Vector3d vtTcurr ; GetInitialToolDir( false, vtTcurr) ;
+            double dExtraZ ;
+            if ( GetExtraZ( vAxVal2, vtTprev, vAxIni2, vtTcurr, dHomeZ, dExtraZ)) {
+               if ( abs( dExtraZ) > EPS_SMALL) {
+                  double dMyHomeZ = dHomeZ + dExtraZ ;
+                  vAxVal2[2] = dMyHomeZ ;
+                  vAxIni2[2] = dMyHomeZ ;
+                  if ( TestCollisionAvoid( vAxVal2, vAxIni2))
+                     dHomeZ = dMyHomeZ ;
                  else
                     bToZmax = true ;
               }
-              // se altrimenti ammessa rotazione a Zmax e richiesta rotazione
-               else if ( GetRotationAtZmax()  &&
-                         (( vAxVal2.size() >= 4  &&  abs( vAxVal2[3] - vAxIni2[3]) > 5)  ||
-                          ( vAxVal2.size() >= 5  &&  abs( vAxVal2[4] - vAxIni2[4]) > 5))) {
-                 // verifico se va bene rotazione assi iniziale e poi movimento
-                  DBLVECTOR vAxMid2 = vAxVal2 ;
-                  vAxMid2[3] = vAxIni2[3] ;
-                  if ( vAxVal2.size() >= 5)
-                     vAxMid2[4] = vAxIni2[4] ;
-                  if ( TestCollisionAvoid( vAxVal2, vAxMid2)  &&
-                       TestCollisionAvoid( vAxMid2, vAxIni2)  &&
-                       pPrevOp->AddRise( vAxVal2)  &&
-                       pPrevOp->AddSpecialRise( vAxMid2, true, GDB_ID_NULL, 5)) {
-                     vAxVal = vAxMid2 ;
-                     bMaxZ = true ;
-                  }
-                  else
-                     return false ;
+               else
+                  bToZmax = true ;
+            }
+           // se altrimenti ammessa rotazione a Zmax e richiesta rotazione
+            else if ( GetRotationAtZmax()  &&
+                      (( vAxVal2.size() >= 4  &&  abs( vAxVal2[3] - vAxIni2[3]) > 5)  ||
+                       ( vAxVal2.size() >= 5  &&  abs( vAxVal2[4] - vAxIni2[4]) > 5))) {
+              // verifico se va bene rotazione assi iniziale e poi movimento
+               DBLVECTOR vAxMid2 = vAxVal2 ;
+               vAxMid2[3] = vAxIni2[3] ;
+               if ( vAxVal2.size() >= 5)
+                  vAxMid2[4] = vAxIni2[4] ;
+               if ( TestCollisionAvoid( vAxVal2, vAxMid2)  &&
+                    TestCollisionAvoid( vAxMid2, vAxIni2)  &&
+                    pPrevOp->AddRise( vAxVal2)  &&
+                    pPrevOp->AddSpecialRise( vAxMid2, true, GDB_ID_NULL, 5)) {
+                  vAxVal = vAxMid2 ;
+                  bMaxZ = true ;
               }
               else
                  return false ;
            }
+           // altrimenti impossibile
+            else
+               return false ;
         }
-         else
-            return false ;
        // Se già a Zmax
         if ( bMaxZ) {
           // non devo fare alcunché
@@ -1921,7 +1994,8 @@ Operation::AdjustStartEndMovements( bool bVerifyPreviousLink)
              // recupero le nuove quote finali (per calcolare il corretto delta)
               pPrevOp->GetFinalAxesValues( false, vAxVal) ;
              // aggiungo risalita a Zsafe
-               if ( ! pPrevOp->AddRise( vAxVal, dSafeZ - vAxVal[2], GDB_ID_NULL, bZHomeDown))
+               double dDelta = ( ! bZHomeDown ? max( dSafeZ - vAxVal[2], 0.) : min( dSafeZ - vAxVal[2], 0.))  ;
+               if ( ! pPrevOp->AddRise( vAxVal, dDelta, GDB_ID_NULL, bZHomeDown))
                  return false ;
              // aggiorno quota iniziale in Z
               vAxIni[2] = dSafeZ ;
@@ -2042,6 +2116,16 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation*
      double dHomeZ ;
      if ( ! m_pMchMgr->GetCurrAxisHomePos( 2, dHomeZ))
         return false ;
+     // aggiungo eventuale ExtraZ
+      const CamData* pCamDataPrev = GetClPathFinalCamData( nPrevClPathId, true) ;
+      const DBLVECTOR& vAxPrev = ( pCamDataPrev != nullptr ? pCamDataPrev->GetAxesVal() : DBLVECTOR()) ;
+      const Vector3d& vtTprev = ( pCamDataPrev != nullptr ? pCamDataPrev->GetToolDir() : V_NULL) ;
+      const Vector3d& vtTcurr = pCamData->GetToolDir() ;
+      double dExtraZ ;
+      if ( GetExtraZ( vAxPrev, vtTprev, vAxCurr, vtTcurr, dHomeZ, dExtraZ)) {
+         if ( abs( dExtraZ) > EPS_SMALL)
+            dHomeZ += dExtraZ ;
+      }
     // modifico quella originale (è la prima del percorso)
      m_pGeomDB->SetName( nEntId, MCH_CL_CLIMB) ;
      DBLVECTOR vAxNew = vAxCurr ;
@@ -2115,14 +2199,15 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation*
         }
        // risalita sopra fine percorso precedente
         DBLVECTOR vAxNew1 ;
+         double dDelta = ( ! bZHomeDown ? max( dSafeZ - vAxPrev[2], 0.) : min( dSafeZ - vAxPrev[2], 0.))  ;
         if ( nPrevClPathId == GDB_ID_NULL) {
            if ( pPrevOp == nullptr  ||  
                 ! pPrevOp->RemoveRise()  ||
-                 ! pPrevOp->AddRise( vAxNew1, dSafeZ - vAxPrev[2], GDB_ID_NULL, bZHomeDown))
+                 ! pPrevOp->AddRise( vAxNew1, dDelta, GDB_ID_NULL, bZHomeDown))
               return false ;
         }
         else {
-            if ( ! AddRise( vAxNew1, dSafeZ - vAxPrev[2], nPrevClPathId, bZHomeDown))
+            if ( ! AddRise( vAxNew1, dDelta, nPrevClPathId, bZHomeDown))
               return false ;
         }
        // aggiungo posizione elevata prima dell'inizio del percorso corrente
@@ -2167,7 +2252,8 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation*
               return true ;
           // aggiungo risalita alla fine del precedente percorso
            DBLVECTOR vAxNew ;
-            if ( ! AddRise( vAxNew, vAxCurr[2] - vAxPrev[2], nPrevClPathId, bZHomeDown))
+            double dDelta = ( ! bZHomeDown ? max( vAxCurr[2] - vAxPrev[2], 0.) : min( vAxCurr[2] - vAxPrev[2], 0.))  ;
+            if ( ! AddRise( vAxNew, dDelta, nPrevClPathId, bZHomeDown))
               return false ;
         }
        // altrimenti Z corrente minore della precedente
@@ -2570,24 +2656,56 @@ Operation::CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR

 //----------------------------------------------------------------------------
 bool
-Operation::GetExtraZ( double dSafeZ, double& dExtraZ, double& dMaxAngV) const
+Operation::GetExtraZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
+                      const DBLVECTOR& vAx2, const Vector3d& vtTool2,
+                      double dSafeZ, double& dExtraZ) const
 {
  // Recupero macchina corrente
   Machine* pMch = ( m_pMchMgr != nullptr ?  m_pMchMgr->GetCurrMachine() : nullptr) ;
   if ( pMch == nullptr)
-      return 0 ;
-  // Se testa con Info ZEXTRA la recupero e la limito alla corsa dell'asse
+      return false ;
+
+  // Flag per posizione sicura in alto o in basso
   int nHeadId = pMch->GetCurrHead() ;
+   bool bZHomeDown ;
+   if ( ! m_pGeomDB->GetInfo( nHeadId, MCH_ZHOMEDOWN, bZHomeDown))
+      bZHomeDown = false ;
+
+  // Estremi dell'asse Z (asse 3, quindi indice 2)
+   double dAxZmax ; pMch->GetCurrAxisMax( 2, dAxZmax) ;
+   double dAxZmin ; pMch->GetCurrAxisMin( 2, dAxZmin) ;
+
+  // Se definito e correttamente eseguito script SpecialGetMaxZ
+   double dMaxZ ;
+   if ( SpecialGetMaxZ( vAx1, vtTool1, vAx2, vtTool2, dMaxZ)) {
+     // se caso standard
+      if ( ! bZHomeDown) {
+         dExtraZ = min( dMaxZ, dAxZmax) - dSafeZ ;
+         return ( dExtraZ > EPS_SMALL) ;
+      }
+     // altrimenti caso con posizione sicura in basso (teste da sotto)
+      else {
+         dExtraZ = max( dMaxZ, dAxZmin) - dSafeZ ;
+         return ( dExtraZ < EPS_SMALL) ;
+      }
+   }
+
+  // Altrimenti verifico se testa ha Info ZEXTRA
   DBLVECTOR vdVal ;
-   if ( m_pGeomDB->GetInfo( nHeadId, MCH_ZEXTRA, vdVal)  &&  vdVal.size() >= 1  &&  vdVal[0] > EPS_SMALL) {
-     // angolo limite per applicare questo allontanamento extra
-      dMaxAngV = 30 ;
-      if ( vdVal.size() >= 2)
-         dMaxAngV = vdVal[1] ;
-     // flag per posizione sicura in alto o in basso
-      bool bZHomeDown ;
-      if ( ! m_pGeomDB->GetInfo( nHeadId, MCH_ZHOMEDOWN, bZHomeDown))
-         bZHomeDown = false ;
+   if ( ! m_pGeomDB->GetInfo( nHeadId, MCH_ZEXTRA, vdVal)  ||  vdVal.empty()  ||  vdVal[0] < EPS_SMALL)
+      return false ;
+  // angolo verticale limite per applicare questo allontanamento extra
+   double dMaxAngV = 30 ;
+   if ( vdVal.size() >= 2)
+      dMaxAngV = vdVal[1] ;
+  // angolo verticale
+   double dAngV = 0 ;
+   if ( vAx1.size() >= 5  &&  vAx2.size() >= 5)
+      dAngV = max( abs( vAx1[4]), abs( vAx2[4])) ;
+   else if ( vAx2.size() >= 5)
+      dAngV = abs( vAx2[4]) ;
+  // verifica angolo verticale
+   if ( dAngV < dMaxAngV) {
     // se caso standard
      if ( ! bZHomeDown) {
         double dZmax ;
@@ -2603,7 +2721,70 @@ Operation::GetExtraZ( double dSafeZ, double& dExtraZ, double& dMaxAngV) const
         return ( dExtraZ < EPS_SMALL) ;
      }
   }
-   return false ;
+  // Lascio provare a Zmax
+   dExtraZ = 0 ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::SpecialGetMaxZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
+                           const DBLVECTOR& vAx2, const Vector3d& vtTool2,
+                           double& dMaxZ) const
+{
+  // recupero la macchina corrente
+   Machine* pMch = ( m_pMchMgr != nullptr ?  m_pMchMgr->GetCurrMachine() : nullptr) ;
+   if ( pMch == nullptr)
+      return false ;
+
+  // verifico numero assi
+   int nNumAx1 = int( vAx1.size()) ;
+   int nNumAx2 = int( vAx2.size()) ;
+   if ( nNumAx1 != nNumAx2  &&  nNumAx1 != 0  &&  ! vtTool1.IsSmall())
+      return false ;
+
+  // costanti
+   static const string EMC_VAR = "EMC" ;              // tabella variabili locali per calcolo
+   static const string EVAR_ERROR = ".ERR" ;          // OUT (int)    codice di errore ( 0 = ok)
+   static const string EVAR_MAXZ = ".MAXZ" ;          // OUT (double) valore Zmax
+   static const string ON_SPECIAL_GETMAXZ = "OnSpecialGetMaxZ" ;
+
+  // verifico definizione funzione
+   if ( ! pMch->LuaExistsFunction( ON_SPECIAL_GETMAXZ))
+      return false ;
+
+  // avvio
+   bool bOk = true ;
+   int nErr = 99 ;
+  // imposto valori parametri
+   bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TOOL, GetToolName()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_HEAD, GetHeadName()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_EXIT, GetExitNbr()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_MCHID, GetOwner()) ;
+   // valori degli assi
+   for ( int i = 1 ; i <= nNumAx1 ; ++ i)
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR), vAx1[i-1]) ;
+   for ( int i = 1 ; i <= nNumAx2 ; ++ i)
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAx2[i-1]) ;
+   // direzioni utensile
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TDIRP, vtTool1) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TDIR, vtTool2) ;
+  // eseguo
+   bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_GETMAXZ, false) ;
+  // recupero valori parametri obbligatori
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MAXZ, dMaxZ) ;
+  // reset
+   bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
+  // segnalo errori
+   if ( nErr != 0) {
+      bOk = false ;
+      string sOut = "  Error in " + ON_SPECIAL_GETMAXZ + " (" + ToString( nErr) + ")" ;
+      LOG_ERROR( GetEMkLogger(), sOut.c_str())
+   }
+   return bOk ;
 }

 //----------------------------------------------------------------------------
@@ -2613,7 +2794,7 @@ Operation::GetRotationAtZmax( void) const
  // Recupero macchina corrente
   Machine* pMch = ( m_pMchMgr != nullptr ?  m_pMchMgr->GetCurrMachine() : nullptr) ;
   if ( pMch == nullptr)
-      return 0 ;
+      return false ;
  // Se testa con Info ROTATZMAX la recupero e restituisco abilitazione rotazione a Zmax
   int nHeadId = pMch->GetCurrHead() ;
   int nVal = 0 ;