EgtMachKernel 1.6u6 :

- aggiustamenti nel calcolo assi rotanti
- aggiunto Hint assi in note di lavorazione come suggerimento angoli iniziali.

Operation.cpp

@@ -449,9 +449,28 @@ Operation::GetClPathFinalAxesValues( int nClPathId, DBLVECTOR& vAxVal)
    return ( vAxVal.size() > 0) ;
 }
 
+//----------------------------------------------------------------------------
+std::string
+Operation::ExtractHint( const std::string& sNotes)
+{
+   const string KEY_HINT = "Hint:" ;
+   string sHint ;
+   STRVECTOR vsCmd ;
+   Tokenize( sNotes, ";", vsCmd) ;
+   for each (const auto& sCmd in vsCmd) {
+     // se per assi rotanti
+      if ( sCmd.find( KEY_HINT) != string::npos) {
+         sHint = sCmd ;
+         ReplaceString( sHint, KEY_HINT, "") ;
+         break ;
+      }
+   }
+   return sHint ;
+}
+
 //----------------------------------------------------------------------------
 bool
-Operation::CalculateAxesValues( void)
+Operation::CalculateAxesValues( const string& sHint)
 {
    if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
       return false ;
@@ -483,7 +502,7 @@ Operation::CalculateAxesValues( void)
    int nLinAxes = m_pMchMgr->GetCurrLinAxes() ;
    int nRotAxes = m_pMchMgr->GetCurrRotAxes() ;
 
-  // assegno gli angoli iniziali
+  // Assegno gli angoli iniziali
    DBLVECTOR vAxRotPrec( nRotAxes, 0.) ;
    DBLVECTOR vAxVal ;
   // se utensile non cambiato, uso gli angoli finali della lavorazione precedente
@@ -498,6 +517,25 @@ Operation::CalculateAxesValues( void)
       for ( int i = 0 ; i < nRotAxes ; ++ i)
          vAxRotPrec[i] = vAxVal[nLinAxes + i] ;
    }
+  // se ci sono suggerimenti validi per gli assi rotanti, li applico
+   if ( ! sHint.empty()) {
+      STRVECTOR vsTok ;
+      Tokenize( sHint, ",", vsTok) ;
+      for each (const auto& sTok in vsTok) {
+         string szKey, szVal ;
+         Split( sTok, "=", true, szKey, szVal) ;
+         for ( int i = 0 ; i < nRotAxes ; ++ i) {
+            string sAxToken ;
+            if ( m_pMchMgr->GetCurrMachine()->GetCurrAxisToken(nLinAxes + i, sAxToken)  &&
+                 szKey == sAxToken) {
+               double dVal ;
+               if ( FromString( szVal, dVal))
+                  vAxRotPrec[i] = dVal ;
+               break ;
+            }
+         }
+      }
+   }
 
   // recupero peso primo asse rotante di testa
    double dRot1W = m_pMchMgr->GetCalcRot1W() ;
@@ -581,12 +619,21 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
            // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
             for ( size_t i = 0 ; i < vAng1.size() ; ++ i)
                m_pMchMgr->GetNearestAngleInStroke( int( i), vAxRotPrec[i], vAng1[i]) ;
+           // se sol.ne indeterminata (sempre il primo asse), assegno il precedente, limitandolo alla corsa
+            if ( nRStat < 0  &&  vAng1.size() >= 1) {
+               vAng1[0] = vAxRotPrec[0] ;
+               m_pMchMgr->LimitAngleToStroke( 0, vAng1[0]) ;
+            }
          }
         // per movimenti successivi
          else {
            // scelgo gli angoli più vicini, per continuità non applico offset per stare nelle corse
             for ( size_t i = 0 ; i < vAng1.size() ; ++ i)
                vAng1[i] = AngleNearAngle( vAng1[i], vAxRotPrec[i]) ;
+           // se sol.ne indeterminata (sempre il primo asse), assegno il precedente
+            if ( nRStat < 0  &&  vAng1.size() >= 1) {
+               vAng1[0] = vAxRotPrec[0] ;
+            }
          }
       }
       if ( abs( nRStat) == 2) {
@@ -597,12 +644,23 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
                m_pMchMgr->GetNearestAngleInStroke( int( i), vAxRotPrec[i], vAng1[i]) ;
                m_pMchMgr->GetNearestAngleInStroke( int( i), vAxRotPrec[i], vAng2[i]) ;
             }
+           // se sol.ne indeterminata (sempre il primo asse), assegno il precedente, limitandolo alla corsa
+            if ( nRStat < 0  &&  vAng1.size() >= 1) {
+               vAng1[0] = vAxRotPrec[0] ;
+               m_pMchMgr->LimitAngleToStroke( 0, vAng1[0]) ;
+               vAng2[0] = vAng1[0] ;
+            }
          }
          else {
            // scelgo gli angoli più vicini, per continuità non applico offset per stare nelle corse
             for ( size_t i = 0 ; i < vAng1.size() ; ++ i) {
                vAng1[i] = AngleNearAngle( vAng1[i], vAxRotPrec[i]) ;
                vAng2[i] = AngleNearAngle( vAng2[i], vAxRotPrec[i]) ;
+              // se sol.ne indeterminata (sempre il primo asse), assegno il precedente
+               if ( nRStat < 0  &&  vAng1.size() >= 1) {
+                  vAng1[0] = vAxRotPrec[0] ;
+                  vAng2[0] = vAng1[0] ;
+               }
             }
          }
         // scelgo la soluzione più vicina ai precedenti
@@ -611,7 +669,7 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
          bool bFirst = true ;
          for ( size_t i = 0 ; i < vAng1.size() ; ++ i) {
            // ignoro gli assi bloccati
-            if ( ! m_pMchMgr->IsKinematicRotAxisBlocked( int( i)))
+            if ( m_pMchMgr->IsKinematicRotAxisBlocked( int( i)))
                continue ;
            // calcolo i delta asse con eventuale peso
             dDelta1 += fabs( vAng1[i] - vAxRotPrec[i]) * ( bFirst ? dRot1W : 1) ;
@@ -653,6 +711,14 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
          }
          string sInfo = "Outstroke : " + m_pMchMgr->GetOutstrokeInfo() ;
          LOG_INFO( GetEMkLogger(), sInfo.c_str())
+        // imposto stato
+         bFirst = false ;
+        // memorizzo i valori degli assi lineari come nuovi precedenti
+         dXprec = dX ;
+         dYprec = dY ;
+         dZprec = dZ ;
+        // memorizzo i valori degli angoli come nuovi precedenti
+         vAxRotPrec = vAng1 ;
          continue ;
       }
      // salvo i valori degli assi