EgtMachKernel 1.6r8 :

- aggiunta gestione SCC (Solution Choice Criterion) nelle lavorazioni - possibilità di calcolo Tip con dimensioni massime anzichè quelle di lavoro - migliorato controllo pezzi prima di inserimento nei grezzi - migliorato caricamento tavola al cambio di gruppo di lavoro - aggiunta prima versione di risalita tra i percorsi di lavorazione in base a controllo collisioni (ora solo box) - in simulazione imposto variabile nome tavola prima di OnDispositionStart.
2016-06-02 07:03:24 +00:00
parent 3cd21182d3
commit fe0cbd0191
37 changed files with 593 additions and 110 deletions
@@ -222,6 +222,11 @@ Milling::SetParam( int nType, int 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 ;
 }
@@ -287,6 +292,12 @@ Milling::SetParam( int nType, double dVal)
   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 ;
@@ -297,6 +308,18 @@ Milling::SetParam( int nType, double dVal)
      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 ;
   }
@@ -472,6 +495,9 @@ Milling::GetParam( int nType, int& nVal) const
   case MPA_LEADOUTTYPE :
      nVal = m_Params.m_nLeadOutType ;
      return true ;
+   case MPA_SCC :
+      nVal = m_Params.m_nSolCh ;
+      return true ;
   }
   return false ;
 }
@@ -511,6 +537,12 @@ Milling::GetParam( int nType, double& dVal) const
   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 ;
@@ -521,9 +553,20 @@ Milling::GetParam( int nType, double& dVal) const
      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 ;
 }
@@ -608,8 +651,12 @@ Milling::VerifyGeometry( SelData Id, int& nSubs)
   // se direttamente la curva
   if ( Id.nSub == SEL_SUB_ALL) {
      pCurve = ::GetCurve( m_pGeomDB->GetGeoObj( Id.nId)) ;
-      if ( pCurve != nullptr  &&  pCurve->GetType() == CRV_COMPO)
-         nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
+      if ( pCurve != nullptr) {
+         if ( pCurve->GetType() == CRV_COMPO)
+            nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
+         else
+            nSubs = 0 ;
+      }
   }
   // altrimenti sottocurva di composita
   else {
@@ -809,14 +856,39 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
      return false ;
   ICurveComposite* pCompo = GetCurveComposite( m_pGeomDB->GetGeoObj( nCopyId)) ;

-  // unisco le parti allineate
-   //if ( ! pCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL))
-   //   return false ;
+  // 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() ;

+  // 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) {
@@ -841,12 +913,14 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
   }

  // recupero distanza da fondo dei grezzi interessati dal percorso
-   double dRbDist ;
-   if ( ! GetDistanceFromRawBottom( m_nPhase, nCopyId, 2 * m_TParams.m_dThick, dRbDist))
-      return false ;
+   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 * vtExtr.z < 0) ? fabs( dThick) : 0)) ;
+   ExeLuaSetGlobNumVar( "TH", ( dThick >= 0 ? 0 : -dThick)) ;
   ExeLuaSetGlobNumVar( "RB", dRbDist) ;
   double dDepth ;
   if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) {
@@ -918,7 +992,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
         LOG_INFO( GetEMkLogger(), "Error in Milling : Entity GetElevation") ;
         return false ;
      }
-      if ( dElev < EPS_SMALL) {
+      if ( dElev < EPS_SMALL  &&  AreSameVectorApprox( vtExtr, Z_AX)) {
         BBox3d b3Crv ;
         pCurve->GetLocalBBox( b3Crv) ;
         dElev = max( 0., b3Raw.GetMax().z - b3Crv.GetMin().z) ;
@@ -934,14 +1008,23 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
         Point3d ptP1 ;
         if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, ptP1))
            return false ;
-        // aggiungo approccio
-         if ( ! AddApproach( ptP1, vtTool, dSafeZ, dElev, dAppr))
-            return false ;
-        // affondo al punto iniziale
-         SetFlag( 0) ;
-         SetFeed( GetTipFeed()) ;
-         if ( AddLinearMove( ptP1) == GDB_ID_NULL)
-            return false ;
+        // aggiungo approccio per frese normali
+         if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
+            if ( ! AddApproach( ptP1, vtTool, dSafeZ, dElev, 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)) {
@@ -982,9 +1065,13 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
            LOG_INFO( GetEMkLogger(), "Error in Milling : LeadOut not computable") ;
            return false ;
         }
-        // aggiungo retrazione
-         if ( ! AddRetract( ptP1, vtTool, dSafeZ, dElev, dAppr))
-            return false ;
+        // aggiungo retrazione per frese normali
+         if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
+           // aggiungo retrazione
+            if ( ! AddRetract( ptP1, vtTool, dSafeZ, dElev, dAppr))
+               return false ;
+         }
+        // per lame non è necessario
      }
   }

@@ -999,7 +1086,7 @@ 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 < m_Params.m_dStartPos + 10 * EPS_SMALL) {
+   if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
     // 1 -> punto sopra inizio
      SetFlag( 1) ;
      Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
@@ -1010,13 +1097,15 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
     // 1a -> punto sopra inizio
      SetFlag( 1) ;
      Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
-      Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - m_Params.m_dStartPos) ;
+      Point3d ptP1a = ptP1b + vtTool * ( dSafeZ - dAppr) ;
      if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
         return false ;
     // 1b -> punto appena sopra inizio
-      SetFlag( 0) ;
-      if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
-         return false ;
+      if ( ( dElev + dAppr) > EPS_SMALL) {
+         SetFlag( 0) ;
+         if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
+            return false ;
+      }
   }
   return true ;
 }
@@ -1025,7 +1114,7 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
 bool
 Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
 {
-   if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) {
+   if ( dSafeZ < dAppr + 10 * EPS_SMALL) {
     // 4 -> movimento di risalita sopra il punto finale
      SetFeed( GetEndFeed()) ;
      Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
@@ -1034,12 +1123,14 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
   }
   else {
     // 4a -> movimento di risalita appena sopra il punto finale
-      SetFeed( GetEndFeed()) ;
      Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
-      if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
-         return false ;
+      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 - m_Params.m_dStartPos) ;
+      Point3d ptP4b = ptP4a + vtTool * ( dSafeZ - dAppr) ;
      if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
         return false ;
   }