EgtMachKernel :

- Aggiunta funzione per tasche passanti per volumi esterni al grezzo.
- migliorata la gestione dei lati aperti piccoli ( da testare )
- migliorie varie .

EgtMachKernel.vcxproj

@@ -100,7 +100,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;I_AM_EMK;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;I_AM_EMK;_VRONI;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>false</MinimalRebuild>
       <OpenMPSupport>false</OpenMPSupport>
       <PrecompiledHeader>Use</PrecompiledHeader>

Operation.cpp

@@ -22,6 +22,7 @@
 #include "/EgtDev/Include/EGkAngle.h"
 #include "/EgtDev/Include/EGkBBox1d.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
@@ -37,6 +38,7 @@
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"
 
 using namespace std ;
 
@@ -564,6 +566,269 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
    return false ;
 }
 
+//----------------------------------------------------------------------------
+bool IsPointOnBox( BBox3d BBox, Point3d pt) {
+   
+   if ( BBox.IsEmpty())
+      return false ;
+
+   int nCheck = 0 ;
+   if (( pt.x - BBox.GetMin().x) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.y - BBox.GetMin().y) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.z - BBox.GetMin().z) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.x - BBox.GetMax().x) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.y - BBox.GetMax().y) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.z - BBox.GetMax().z) < EPS_SMALL)
+      ++ nCheck ;
+   
+   if ( nCheck >= 2)
+      return true ;
+
+   return false ;
+
+}
+
+
+//----------------------------------------------------------------------------
+bool 
+Operation::GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3d vtDir,
+                                    double& dDist, Vector3d& vtNorm) const
+{
+
+  // controllo MachManager e database geometrico
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return false ;
+
+  // la distanza  negativa se il punto  interno, positiva se esterno, 0 se sulla suprificie
+   const double RAY_LEN = 100000 ;
+   bool bIsInside = false ;      // se punto interno ad un RawPart
+   bool bIsPointOn = false ;     // se il punto  stato trovato su una faccia
+   bool bIsOnLoop = false ;      // se il punto  su un loop
+   bool bIsOnBox = false ;       // se il punto  su un Box3D
+   bool bSkip = false ;          // se salto controlli sui bordi
+
+  // vettore dei grezzi
+   ISURFTMPOVECTOR vSrfRawPart ;
+
+   int nRawId = m_pMchMgr->GetFirstRawPart() ;
+   while( nRawId != GDB_ID_NULL) {
+     
+     // verifico che il grezzo compaia nella fase
+      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) {
+
+        // recupero l'oggetto dal database con tale Id
+         int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
+         const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
+
+        // recupero il frame in cui si trova
+         Frame3d frRaw ;
+         m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
+         if ( pGObj == nullptr)
+            return false ;
+
+        // controllo che sia una Trimesh
+         if ( pGObj->GetType() == SRF_TRIMESH) {
+
+           // Trimesh della parte p-esima
+            PtrOwner<ISurfTriMesh> pStmRawPart( CloneSurfTriMesh( GetSurfTriMesh( pGObj))) ;
+            if ( IsNull( pStmRawPart))
+               return false ;
+
+           // porto la trimesh in globale
+            pStmRawPart->ToGlob( frRaw) ;
+
+           // salvo la superificie
+            vSrfRawPart.emplace_back( pStmRawPart->Clone()) ;
+
+           // distanza dalla parte p-esima
+            double dCurrDist = 0 ;
+
+           // recupero la distanza tra il punto e la parte p-esima
+            DistPointSurfTm distPtStm( ptP, *pStmRawPart) ;
+            if ( ! distPtStm.GetDist( dCurrDist))
+               return false ;
+
+           // controllo se il punto  dentro al grezzo
+            if ( distPtStm.IsPointInside()) {
+               bIsInside = true ;
+               bSkip = true ;
+            }
+
+            if ( dCurrDist < EPS_SMALL  &&  !bSkip) {
+              // controllo se sono su un Loop
+               POLYLINEVECTOR vP ;
+               bool bIsCurrOnLoop = false ;
+               for ( int i = 0 ; i < pStmRawPart->GetFacetCount() ; ++ i) {
+                  pStmRawPart->GetFacetLoops( i, vP) ;
+                  for ( int j = 0 ; j < ( int)vP.size() &&  !bIsCurrOnLoop ; ++ j) {
+                     PtrOwner<ICurveComposite> pCrvEdge( CreateCurveComposite()) ;
+                     if ( IsNull( pCrvEdge))
+                        return false ;
+                     pCrvEdge->FromPolyLine( vP[j]) ;
+                     if ( !pCrvEdge->IsValid()  ||  pCrvEdge->GetCurveCount() == 0)
+                        return false ;
+                     if ( pCrvEdge->IsPointOn( ptP))
+                        bIsCurrOnLoop = true ;
+                  }
+               }
+               
+              // se il punto sta sulla curva...
+               if ( bIsCurrOnLoop) {
+                  if ( bIsOnLoop) { // se ho gi trovato una curva che contiene il punto ...
+                     BBox3d bCurrBox ;
+                     if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
+                        return false ;
+
+                     if ( IsPointOnBox( bCurrBox, ptP)) { // se il punto sta sul Box
+                        if ( bIsOnBox) { // se il punto stava gi su un altro Box
+                           bIsInside = false ;
+                           bSkip = true ;
+                        }
+                        else // se il punto non stava gi su un box
+                           bIsInside = true ;
+
+                        bSkip = true ;
+                     }
+                     else // se il punto non sta sul box
+                        bIsInside = true ;
+
+                  }
+                  else { // se  la prima curva a contenere il punto
+                     bIsPointOn = true ;
+                    // controllo se il punto sta sulla faccia del box del grezzo corrente
+                     BBox3d bCurrBox ;
+                     if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
+                        return false ;
+                    // controllo se il punto sta su una faccia del box
+                     if ( IsPointOnBox( bCurrBox, ptP))
+                        bIsOnBox = true ;
+                  }
+               }
+              // se il punto non sta sulla curva ...
+               else {
+                  if ( bIsPointOn) {
+                     bIsInside = true ;
+                     bSkip = true ;
+                  }
+                  else
+                     bIsPointOn = true ;
+               }
+
+            }
+         }
+      }
+
+     // passo al grezzo successivo
+      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
+   }
+
+   if ( bSkip) {
+      bIsPointOn = false ;
+      bIsOnLoop = false ;
+      bIsOnBox = false ;
+   }
+
+   double dCurrDist = bIsInside ? -INFINITO : INFINITO ;   // distanza attuale
+   dDist = dCurrDist ;
+   double dTmpCurrDist = 0 ;
+
+   for ( int i = 0 ; i < int( vSrfRawPart.size()) ; ++ i) {
+
+      ILSIVECTOR vInfo ;   // info
+      Triangle3d Tria ;    // triangolo della trimesh intersecato
+
+     // recupero la distanza tra il punto e la parte p-esima
+      if ( IntersLineSurfTm( ptP, vtDir, RAY_LEN, *vSrfRawPart[i], vInfo)) {
+
+         if ( vInfo.empty())
+            continue ;
+
+         DistPointSurfTm distPtStm( ptP, *vSrfRawPart[i]) ;
+         if( ! distPtStm.GetDist( dTmpCurrDist))
+            return false ;
+
+         if (( bIsPointOn  &&  !bIsInside)) { // punto sulla superificie totale dei grezzi
+           // se  il grezzo  quello giusto ...
+            if ( dTmpCurrDist < EPS_SMALL) {
+               dDist = 0 ;
+               vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+               vtNorm = Tria.GetN() ;
+               return true ;
+            }
+            else { // se sono su un altro ... ( prima o poi ritorno al controllo sopra ...)
+            }
+         }
+         else if (( int)vInfo.size() == 1  &&  bIsInside) {
+            if ( distPtStm.IsPointInside()  ||  dTmpCurrDist < EPS_SMALL) {
+              // se punto interno alla grezzo corrente
+               double dUCurr = vInfo[0].dU ;
+               // se direzione || ad una faccia faccia, ma punto non interno al grezzo corrente
+               if ( vInfo[0].nILTT == ILTT_SEGM  ||  vInfo[0].nILTT == ILTT_EDGE)
+                   double dUCurr = - vInfo[0].dU2 ;
+               if ( dUCurr > dCurrDist) {
+                  dCurrDist = dUCurr ;
+                  vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+            else { // se interno ma non al grezzo corrente ( prima o poi ritono al controllo sopra )
+            }
+         }
+         else if (( int)vInfo.size() > 1) { // se la linea trapassa il grezzo corrente (entra ed esce)...
+            if ( bIsInside) { // e il punto  interno ( quindi non al grezzo corrente )
+               double dUCurr = 0 ;
+               int nT ;
+               for ( int j = 0 ; j < ( int)vInfo.size() ; ++ j) {
+                  IntLinStmInfo Info = vInfo[j] ;
+                  if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+                    // se prosegue un tratto precedente, non devo controllare sia minimo
+                     dUCurr = Info.dU2 ;
+                     nT = Info.nT ;
+                     //break ; ???????
+                  }
+                 // se altrimenti intersezione puntuale, verifico che esca (coseno >= 0)
+                  else if ( Info.dCosDN > - COS_ORTO_ANG_ZERO) {
+                     dUCurr = Info.dU ;
+                     nT = Info.nT ;
+                     break ;
+                  }
+                 // se altrimenti  la prima ed entra ( non la considero ...)
+                  else {
+                  }
+
+               }
+               if ( dUCurr > dCurrDist) { // tengo la distanza pi grande 
+                  dCurrDist = dUCurr ;
+                  vSrfRawPart[i]->GetTriangle( nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+            else { // se invece  un punto esterno a tutto
+               if ( vInfo[0].dU < dCurrDist) { // tengo la distanza ( positiva) pi grande
+                  dCurrDist = vInfo[0].dU ;
+                  vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+         }
+      }
+   }
+
+
+   if ( dCurrDist > INFINITO - 1  &&  ! bIsInside) // non ho intersecato mai nessun grezzo
+      dDist = INFINITO ;
+   if ( dCurrDist < -INFINITO + 1  &&  bIsInside) // sono interno ma non interseco un grezzo ... errore
+      return false ;
+   dDist = bIsInside ? - dCurrDist : dCurrDist ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -824,13 +1089,25 @@ Operation::GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, dou
 {
    if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
       return false ;
-  // recupero distanza da fondo dei grezzi interessati o no dal percorso
-   dRbDist = 0 ;
-   dAllRbDist = 0 ;
+
+   // ricerco grezzi interessati dal percorso
    BBox3d b3Compo ;
    if ( ! m_pGeomDB->GetGlobalBBox( nPathId, b3Compo))
       return false ;
-   b3Compo.Expand( dToler, dToler, 0) ;
+   return GetDistanceFromRawBottom( nPhase, b3Compo, dToler, dRbDist, dAllRbDist) ;
+
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler, double& dRbDist, double& dAllRbDist) const
+{
+   if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
+      return false ;
+  // recupero distanza da fondo dei grezzi interessati o no dal percorso
+   dRbDist = 0 ;
+   dAllRbDist = 0 ;
+   b3Test.Expand( dToler, dToler, 0) ;
    int nRawId = m_pMchMgr->GetFirstRawPart() ;
    while ( nRawId != GDB_ID_NULL) {
      // verifico che il grezzo compaia nella fase
@@ -838,8 +1115,8 @@ Operation::GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, dou
          BBox3d b3Raw ;
          int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
          if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw)) {
-            double dDist = b3Compo.GetMax().z - b3Raw.GetMin().z ;
-            if ( b3Compo.OverlapsXY( b3Raw)  &&  dDist > dRbDist)
+            double dDist = b3Test.GetMax().z - b3Raw.GetMin().z ;
+            if ( b3Test.OverlapsXY( b3Raw) && dDist > dRbDist)
                dRbDist = dDist ;
             if ( dDist > dAllRbDist)
                dAllRbDist = dDist ;
@@ -1142,6 +1419,9 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
    pCompo->GetExtrusion( vtExtr) ;
    double dThick = 0 ;
    pCompo->GetThickness( dThick) ;
+  // recupero le propriet� temporanee
+   int nProp0 = pCompo->GetTempProp( 0) ;
+   int nProp1 = pCompo->GetTempProp( 1) ;
   // verifico se ci sono tante linee corte
    int nSmallLineCnt = 0 ;
    const ICurve* pCrv = pCompo->GetFirstCurve() ;
@@ -1237,6 +1517,10 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
    pCompo->SetExtrusion( vtExtr) ;
    pCompo->SetThickness( dThick) ;
 
+  // riassegno le propriet� temporanee
+   pCompo->SetTempProp( nProp0, 0) ;
+   pCompo->SetTempProp( nProp1, 1) ;
+
    return true ;
 }
 

Operation.h

@@ -20,6 +20,7 @@
 #include "/EgtDev/Include/EGkUserObj.h"
 #include "/EgtDev/Include/EGkSelection.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
+#include "/EgtDev/Include/EGkStmStandard.h"
 
 class MachMgr ;
 class CamData ;
@@ -89,6 +90,8 @@ class Operation : public IUserObj
                                  double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ;
       bool   GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
                                  double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ;
+      bool   GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3d vtDir,
+                                      double& dDist, Vector3d& vtNorm) const ;
       bool   GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) const ;
       bool   GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double dExpand,
                                         double& dDist, Vector3d& vtDir) const ;
@@ -99,6 +102,7 @@ class Operation : public IUserObj
                   { double dDummy ;
                     return GetDistanceFromRawBottom( nPhase, nPathId, dToler, dRbDist, dDummy) ; }
       bool   GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, double& dRbDist, double& dAllRbDist) const ;
+      bool   GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler, double& dRbDist, double& dAllRbDist) const ;
       bool   GetRawGlobBox( int nPhase, int nPathId, double dToler, BBox3d& b3Raw) const ;
       bool   GetRawGlobBox( int nPhase, const BBox3d& b3Test, double dToler, BBox3d& b3Raw) const ;
       bool   GetCurrRawsGlobBox( BBox3d& b3Raw) const ;

Pocketing.h

@@ -19,6 +19,9 @@
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkCurveArc.h"
 
 //----------------------------------------------------------------------------
 class Pocketing : public Machining
@@ -66,53 +69,219 @@ class Pocketing : public Machining
       Pocketing( void) ;
 
    private :
+     // Debug functions ----
+      void DrawLoopsSurf( const ISurfFlatRegion* pSfr, bool bWithSurf = true, Color Col = Color( 0., 0., 1., 0.45), 
+                          bool bAlphaCoverage = false) ;
+      void DrawSimpleSurf( const ISurfFlatRegion* pSrf, Color Col = Color( 0., 0., 1., 0.45)) ;
+      void DrawVectorCurves( const ICRVCOMPOPOVECTOR& vCrv) ;
+      void DrawSimpleCurve( const ICurveComposite* pCrv, bool bUniform = false, Color Col = WHITE) ;
+      void DrawSimpleTriMesh( const ISurfTriMesh* pStm, Color Col = Color( 0., 0., 0., 1.)) ;
+      void DrawSimplePoint( const Point3d& pT, Color Col = WHITE) ;
+      void DrawSimpleVector( const Vector3d& vt, Point3d ptPos = ORIG, Color Col = WHITE) ;
+     // --------------------
+
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
-      bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
+      bool GetCurvesAndPartialVolume( SelData Id, ICURVEPLIST& lstPC, ISurfTriMesh* pStmTmp, Vector3d& vtN) ;
+      bool GetForcedClosed( void) ;
       bool SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen = nullptr) ;
       bool ResetCurveAllTempProp( ICurve* pCurve) ;
       bool Chain( int nGrpDestId) ;
       bool ProcessPath( int nPathId, int nPvId, int nClId) ;
       bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dLen, double& dElev) const ;
       bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
-      bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ;
-      bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                      double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ;
-      bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ;
-      bool OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ,
-                            Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ;
+      bool GeneratePocketingPv( int nPathId, const ISurfTriMesh* pStm_PartVolume) ;
+      bool CheckSimpleOverlap( const ICurve* pCrv, const ICurveComposite* pCrvOri, int& nStat, double dToll) ;
+      bool CalcDepth( const int nId, const Vector3d& vtExtr, double dThick, double& dDepth) ;
+      bool ChainCurveArray( ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo) ;
+      bool CreateStmForIntersection( ISurfTriMesh* pStm, ICRVCOMPOPOVECTOR& vCrvCompo, const Vector3d& vtN) ;
+      bool CalcOffsExtensionsForCurves( const ICurveComposite* pCrvCompo, const Vector3d& vtN, double& dExt) ;
+      bool GetExtendedLoopToFitStmVolume( ICurveComposite* pCrvLoop, const double& dExt, const Vector3d& vtN) ;
+      bool GetCurrentPart( const PNTVECTOR& vPtInside, ISurfTriMesh* pStmPart) ;
+      bool SetPocketingVolume( const PNTVECTOR& vPtInside, ISurfTriMesh* pStm) ;
+      bool AdjustPocketingSideForVolumePart( ISurfTriMesh* pStmVolPart, const Vector3d& vtTool) ;
+      bool SewingMissingFacesOnPlanes( ISurfTriMesh* pStm, const Plane3d& plPlane) ;
+      bool ChainBisectors( ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo) ;
+      bool ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d& ptS,
+                                   const Point3d& ptE, ICurveComposite* pCrvPath) ;
+      bool GetSpecialElevation( const ISurfFlatRegion* pSfr, const ICurveLine* pLine, const bool bInVsOut,
+                                double& dElev) ;
+
+      bool GetDangerSfrForSideStep( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm_Part, const double dExtraLenInOut,
+                                    ISurfFlatRegion* pSfrDanger) ;
+      bool AdjustTrapezoidSpiralLeadInLeadOutForSideAngle( ICurveComposite* pMCrv, const double dExtraLenInOut,
+                                                           const int nOutsideRaw, const Vector3d& vtN) ;
+      bool GetRaw( ISurfTriMesh* pStmRaw) ;
+      bool SliceVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const ISurfTriMesh* pSt_Raw,
+                        ISURFFRPOVECTOR& vSrfSliced, ISURFFRPOVECTOR& vSfrLimit, std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags,
+                        BOOLVECTOR& vbChangedPrec, VCT3DVECTOR& vVtTrasl, int& nStep, const Vector3d vtTool,
+                        const double dElev, const double dDepth, const double dStep, double& dExtraLenInOut) ;
+      bool TranslateVolumeFaces( const double dTrasl, Frame3d& frElevation, ISurfTriMesh* pStmVol, ISurfTriMesh* pStm_Part,
+                                 ISurfTriMesh* pStmRaw) ;
+      bool CalcExtraSteps( const ISurfTriMesh* pStmVol, VCT3DVECTOR& vVtTrasl, int& nStep, const double dElev,
+                           const double dDepth, const double dStep, INTVECTOR& vIndExtraSteps,
+                           ISURFTMPOVECTOR& vStmES_Edges_OC) ;
+      bool CutVolumeByPlane( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const Vector3d& vtTrasl,
+                             const bool bIsExtraStep, ISurfFlatRegion* pSfrResult) ;
+      bool CheckSideAngleForVolume( const ISurfTriMesh* pStmVol_Sliced, const ISurfTriMesh* pStm_Part,
+                                    ISurfFlatRegion* pSfr_Projection, double& dExtraLenInOut, ISurfFlatRegion* pSfr) ;
+      bool ProjectVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const Vector3d& vtTrasl,
+                          const Vector3d& vtTraslPrec, const bool bIsExtraStep, ISurfFlatRegion* pSfrOpenProjPrec,
+                          ISurfFlatRegion* pSfr, const bool bOneStep, double& dExtraLenInOut) ;
+      bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const bool bOnIsClosed = false) ;
+      bool SimplifySfrLoops( ISurfFlatRegion* pSfr) ;
+      bool GetCurvesForOptimizedPocketing( ISurfFlatRegion* pSfr, ICRVCOMPOPOVECTOR& vCrvOEWithFlags) ;
+      bool ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrLimit) ;
+      bool AdjustContourWithOpenEdges( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vCrvIsl, const double dDiam,
+                                       const double dOffR, const double dStep, const ISurfFlatRegion* pSfrLimit) ;
+      bool AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvIsland,
+                           const double dParS, const double dParE, const Vector3d& vtTanS,
+                           const Vector3d& vtTanE, const double dRad, const double dDiamJ,
+                           const ISurfFlatRegion* pSfrLimit, ICurveComposite* pCrvBorder) ;
+      bool GetProjectionOfStmToNotPocket( const ISurfTriMesh* pStm, const ISurfTriMesh* pStmVol,
+                                          const Vector3d& vtTrasl, ISurfFlatRegion* pSfrProj) ;
+      bool CreateSurfFrIncidence( const ICurveComposite* pCrv, const Vector3d& vtTanS, const Vector3d& vtTaneE, 
+                                  const double dRad, ISurfFlatRegion* pSfrInc) ;
+      bool GetNewSfrByAnotherPocketing( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrNoExtendedByOpenEdges,
+                                        const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part,
+                                        const ISurfFlatRegion* pSfrLimit) ;
+      bool GetHomogeneousParts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool OptimizedSpiralCirle( const ICurveComposite* pCrvCompo, const double dToll, double& dRad,
+                                 Point3d& ptC, bool& bIsCirlce) ;
+      bool ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
+      bool OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, PNTVECTOR& vPtStart,
+                                       VCT3DVECTOR& vVtOut, BOOLVECTOR& vbMidOut) ;
+      bool SetPtStartForPath( ICurveComposite* pCrv0, const ISurfFlatRegion* pSrfToWork, const Point3d& ptEndPrec,
+                              const Frame3d& frPocket, Point3d& ptStart, Vector3d& vtMidOut, bool& bMidOut,
+                              int nOffs = 0, ICurveComposite* pCrvOrig = nullptr) ;
+      bool SetSpecialPtStartForOpenEdges( const ICurveComposite* pCrvOrig, const Frame3d& frPocket,
+                                          ICurveComposite* pCrvCompo, Point3d& ptStart, Vector3d& vtMidOut,
+                                          bool& bMidOut) ;
+      bool GetOptCrvIndex( const std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int nStep, ISurfFlatRegion* pSrfChunkFinal,
+                           int& nIndex) ;
+      bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTrap, Frame3d& frTrap,
+                                  double& dPocketSize, int& nBase, int& nSecondBase) ;
+      bool GetBoxCrvOptTrap( const int nCrv, const ICurveComposite* pCrvCompo, const double dDiam, int& nType, ICurveComposite* pCrvBox) ;
+      bool CheckTrapezoidClosedEdgePosition( const ICurveComposite* pCrvCompo, const int nCrvInd, const double dDimBoxY,
+                                             INTVECTOR& vIndClosedSides, bool& bOk,
+                                             ICurveComposite* pCrvTrap) ;
+      bool CheckSecondBaseTrapezoid( const ICurveComposite* pCrvCompo, const int nCrvInd, int& nSecondBase) ;
+      bool PreparareTrapezoidTwoBases( const ICurveComposite* pCrvCompo, const double dDiam, const int nType, int& nBase,
+                                       int& nSecondBase, bool& bOk, ICurveComposite* pCrvTrap) ;
+      bool GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr,
+                        const double dThick, double dToll = 5 * EPS_SMALL) ;
+      bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ;
+      bool GetCoeffLinArc( const ICurveArc* pArc, double dDiam, double& dSubArc) ;
+      bool GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl,
+                               const Frame3d& frPocket, Point3d& ptMid, Vector3d& vtMidOut) ;
+      bool AdjustContourStart( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl, bool bOrder = false,
+                               Point3d ptRef = P_INVALID) ;
+      bool GetParamForPtStartOnEdge( const ICurve* pCrv, const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl,
+                               double& dPar) ;
+      bool CheckForRemovingIsland( const ICurveComposite* pCrvIslandBorder, double dOffs, bool bRemove) ;
+      bool AddZigZag( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                      VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink) ;
+      bool OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d & vtTool, double dDepth, double dSafeZ,
+                            Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, 
+                            ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs,
+                            int& nClosedSides, bool& bTwoOpposite) ;
       bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, 
-                                          bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
+      bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag,
+                                         Vector3d& vtDir,  double& dOffs) ;
+      bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds,
+                                          bool& bOptimizedZigZag, bool& bOpposite, Vector3d& vtDir,  double& dOffs) ;
       bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, 
-                                            bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, 
-                                         const INTVECTOR& vnClosedIds, double& dOffs) ;
+                                            bool& bOpposite, Vector3d& vtDir,  double& dOffs) ;
+      bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
+                                         const INTVECTOR& vnClosedIds,  double& dOffs) ;
       bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;
-      bool AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                      double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
-      bool AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                        double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bMidOpen,
-                        const Point3d& ptMidOpen, const Vector3d& vtMidOut, int nPathId) ;
-      bool AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                         double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ;
-      bool CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, 
-                       ICurveComposite* pMCrv, ICurveComposite* pRCrv, int nPathId, bool& bOptimizedTrap) ;
-      bool CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, const ICurve* pCrvBound,
+      bool AddOneWay( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                      VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool AddSpiralIn( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                        VCT3DVECTOR& vVtTrasl, ISURFFRPOVECTOR& vSrfLimit, const Vector3d& vtTool, const Vector3d& vtExtr,
+                        const double dDepth, const double dElev, const double dMaxElev, const double dOkStep,
+                        const bool bSplitArcs, const double dExtraLenInOut) ;
+      bool AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                         VCT3DVECTOR& vVtTrasl, ISURFFRPOVECTOR& vSrfLimit, const Vector3d& vtTool, const Vector3d& vtExtr,
+                         double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs,
+                         const double dExtraLenInOut) ;
+      bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, const Point3d& ptEndPrec, Vector3d& vtMidOut , bool& bMidOut,
+                       bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags,
+                       bool vbChangedPrec, bool& bOptimizedTrap) ;
+      bool CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const double dOffs, const int nIter,
+                                     const int nOffsCount, const Vector3d& vtN, bool& bInsert) ;
+      bool CreateSpiralPocketingPath( ICRVCOMPOPOVECTOR& vOffs, ICURVEPOVECTOR& vLinks,
+                                      const ICRVCOMPOPOVECTOR& vOffsClosedCurves, const ICRVCOMPOPOVECTOR& vOffsFirstCurve) ;
+      bool GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICURVEPOVECTOR& vLinks,
+                               const ICurveComposite* pCrv_orig, ISurfFlatRegion* pSrfToCut) ;
+      bool GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveComposite* pCrv) ;
+      bool RemoveFirstLoopFromSfr( ISurfFlatRegion* pSrfOrig) ;
+      bool RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffsClosedCurves,
+                             ICRVCOMPOPOVECTOR& vOffsFirstCurve, ICURVEPOVECTOR& vLinks) ;
+      bool RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECTOR& vOffsFirstCurve,
+                                        int& nOptFlag, Point3d& ptCentroid, ICurveComposite* pCrvPath) ;
+      bool CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus, ICurveComposite* pCrv1,
+                                    ICurveComposite* pCrv2, int& nIndex) ;
+      bool CutLinkToClosestPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vOffs, const Point3d& ptFocus,
+                                  ICurveComposite* pCrv1, ICurveComposite* pCrv2, bool& bFound, int& nIndex) ;
+      bool GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, Point3d& ptC, bool bCir,
+                                     ICRVCOMPOPOVECTOR& VFirstOff, ICurveComposite* pCrvNewCurve) ;
+      bool GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, ICurveComposite* pCrvPath,
+                                 ICRVCOMPOPOVECTOR& VFirstOff, ICRVCOMPOPOVECTOR& VoffsCl, ICurveComposite* pCrvNewCurve) ;
+      bool ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pCrvPath, ICurveComposite* pPath1,
+                                      ICurveComposite* pPath2, ICRVCOMPOPOVECTOR& vOffsCL) ;
+      bool GetCurveWeightInfo( const ICurveComposite* pCrvCompo, double dMaxLen, double& dToTRot, int& nSmallArcs, int& nSmallLines) ;
+      bool ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv2, int nP, double dPerP, double dMaxLen, int& nC) ;
+      bool CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, const ICRVCOMPOPOVECTOR& vOffIslands,
                             ICurveComposite* pCrvLink) ;
+      bool CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd,
+                                   const Vector3d& vtEnd, const double dParMeet,
+                                   const ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink) ;
+      bool ModifyBiArc( ICurve* pCrvBiArc, double dCutToll, ICurveComposite* pNewCrv) ;
+      bool CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) ;
+      bool CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, const ICRVCOMPOPOVECTOR& vOffs,
+                              const ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink,
+                              double dLenPercS = 0.01, double dLenPercE = 0.01, int nMaxIter = 2) ;
       bool CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd,
                                       const ICurve* pCrvBound, ICurveComposite* pCrvLink) ;
       bool CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double dOutRad, double dIntRad,
                              bool bSplitArcs, ICurveComposite* pMCrv, ICurveComposite* pRCrv) ;
-      bool CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtDir, double dPocketSize,  
-                                ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
+      bool CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double dPocketSize, int nBase,
+                                int nSecondBase, ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
+      bool CalcSingleOffsetSpiral( const ISurfFlatRegion* pSfr, ICurveComposite* pOffs,
+                                   Point3d& ptStart, Vector3d& vtMidOut, bool& bMidOut) ;
       bool CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc) ;
-      bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;      
-      bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) ;
-      bool SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveComposite* pCrvPocket) ;
+      bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, int nBase,int nSecondBase,
+                                      bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;
+      bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, 
+                                           bool bStart) ;
+      bool SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const bool bEven, const ICurveComposite* pCrvPocket) ;
       bool AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool, 
                                                   double dDepth, int& nOutsideRaw) ;
-      bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ;
+      bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, 
+                                                bool& bIsOutsideRaw) ;
+      bool GetSignedDistFromRealDirection( const Point3d ptP, const Vector3d vtDir, double& dDist, Vector3d& vtNorm) ;
+      double GetMinFeed( void ) const { return GetFeed() * GetSideStep() / m_TParams.m_dDiam ; }
+      double GetMaxFeed( void ) const { return GetFeed() ; }
+      bool GetFeedForParam( double& dPar, double& dFeed) ;
+      bool AssignDefaultFeed( ICurveComposite* pCrv) ;
+      bool DrawColoredCrvForFeedTest( ICurve* pCurve, double dFeed) ;
+      bool AssignFeedForOpenEdge( ICurveComposite* pCrv, const ICurveComposite* pCrvOF_ori) ;
+      bool AssignFeedForLineInOut( ICurveComposite* pCrv, const bool bIsIn) ;
+      bool AssignFeedOnCorners( ICurveComposite* pCrv, const ICurveComposite* pCrv_orig, const double dLenToll) ;
+      bool AssignFeedForEdgeCleaning( ICurveComposite *pCrv, const ICRVCOMPOPOVECTOR& vCrvOF_orig, int nInd = -1) ;
+      bool AssignFeedZigZagOneWay( ICurveComposite* pCompoLine, const bool bIsLink, const ICURVEPOVECTOR& vLAbove,
+                                   const ICURVEPOVECTOR& vLUnder, const ICRVCOMPOPOVECTOR& vAddedLinks) ;
+      bool AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfRemoved_offs, const bool bIsLink,
+                             const ICRVCOMPOPOVECTOR& vLinks_done, const ICurveComposite* pCrv_orig, double dToll) ;
+      bool AssignFeedSpiralOpt( const int nOptType, ICurveComposite* pCrv) ;
+      bool AssignFeedCrvOnUnclearedRegions( ICurveComposite* pCrv) ;
+      bool AssignFeedForReturnPath( ICurveComposite* pCrv) ;
+      bool VerifyLeadInHelix( ISurfFlatRegion* pSrfChunk, const Point3d& ptCen, double dRad) const ;
+      bool VerifyLeadInZigZag( ISurfFlatRegion* pSrfChunk, const Point3d& ptPa, const Point3d& ptPb) const ;
       bool ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs) ; 
       bool AddEpicycles( ICurveComposite * pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound = nullptr) ;
       bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
@@ -125,23 +294,23 @@ class Pocketing : public Machining
                        double dElev, double dAppr) ;
       bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                             const ICurveComposite* pRCrv, Point3d& ptP1) const ;
-      bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
-                      const ICurveComposite* pCompo, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
+      bool AddLeadIn( const ICurveComposite* pCrvCompo, const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
+                      const Vector3d& vtEnd, const Vector3d& vtN, ISurfFlatRegion* pSrfChunk,
+                      const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
                       bool bNoneForced = false, bool bSkipControl = false) ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
-                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
-                       Point3d& ptP1, double& dElev) ;
+                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1,
+                       double& dElev, bool bRecalcElev = true) ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                        const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
-                       Point3d& ptP1, double& dElev, bool& bOppositeHome) ;
+                       Point3d& ptP1, double& dElev, bool& bOppositeHome, bool bRecalcElev = true) ;
+      bool SetLeadInPointStart( const Point3d& ptCurr, const Vector3d vtN,
+                                const bool& bAtLeft, Vector3d& vtStart, Point3d& ptDest) ;
+      bool CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFlatRegion* pSfr,
+                           const ISurfFlatRegion* pSfrLimit, ICurveComposite* pCrvStepLink) ;
       double GetRadiusForStartEndElevation( void) const ;
-      bool GetForcedClosed( void) ;
-      bool GetMidOfLongestOpenSide( const ICurveComposite* pCompo, Point3d& ptMid, Vector3d& vtMidOut) ;
-      bool AdjustContourWithOpenEdges( ICurveComposite* pCompo) ;
-      bool AdjustContourStart( ICurveComposite* pCompo) ;
-      bool VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const ;
-      bool VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const ;
-      bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist, Vector3d& vtNorm) ; 
+
+     // ===================================================================
 
    private :
       double GetSpeed( void) const
@@ -177,21 +346,31 @@ class Pocketing : public Machining
            return m_Params.m_nLeadOutType ; }
 
    private :
-      SELVECTOR     m_vId ;             // identificativi entità geometriche da lavorare
-      PocketingData m_Params ;          // parametri lavorazione
-      ToolData      m_TParams ;         // parametri utensile
-      double        m_dTHoldBase ;      // posizione base del porta-utensile
-      double        m_dTHoldLen ;       // lunghezza del porta-utensile
-      double        m_dTHoldDiam ;      // diametro del porta-utensile
-      double        m_dMaxHelixRad ;    // raggio massimo attacco ad elica nel caso di cerchi
-      int           m_nStatus ;         // stato di aggiornamento della lavorazione
-      int           m_nPockets ;        // numero di percorsi di svuotatura generati
-      bool          m_bTiltingTab ;     // flag utilizzo tavola basculante
-      Vector3d      m_vtTiltingAx ;     // versore direzione eventuale asse basculante
-      bool          m_bAboveHead ;      // flag utilizzo testa da sopra
-      bool          m_bAggrBottom ;     // flag di utilizzo dell'aggregato da sotto
-      Vector3d      m_vtAggrBottom ;    // vettore direzione ausiliaria aggregato da sotto
-      AggrBottom    m_AggrBottom ;      // dati eventuale aggregato da sotto
-      bool          m_bOpenOutRaw ;     // flag forzatura lati aperti sempre fuori dal grezzo
-      double        m_dOpenMinSafe ;    // minima distanza di sicurezza di attacco su lato aperto
+      SELVECTOR     m_vId ;                   // identificativi entit� geometriche da lavorare
+      PocketingData m_Params ;                // parametri lavorazione
+      ToolData      m_TParams ;               // parametri utensile
+      double        m_dTHoldBase ;            // posizione base del porta-utensile
+      double        m_dTHoldLen ;             // lunghezza del porta-utensile
+      double        m_dTHoldDiam ;            // diametro del porta-utensile
+      double        m_dMaxHelixRad ;          // raggio massimo attacco ad elica nel caso di cerchi
+      int           m_nStatus ;               // stato di aggiornamento della lavorazione
+      int           m_nPockets ;              // numero di percorsi di svuotatura generati
+      bool          m_bTiltingTab ;           // flag utilizzo tavola basculante
+      Vector3d      m_vtTiltingAx ;           // versore direzione eventuale asse basculante
+      bool          m_bAboveHead ;            // flag utilizzo testa da sopra
+      bool          m_bAggrBottom ;           // flag di utilizzo dell'aggregato da sotto
+      Vector3d      m_vtAggrBottom ;          // vettore direzione ausiliaria aggregato da sotto
+      AggrBottom    m_AggrBottom ;            // dati eventuale aggregato da sotto
+      bool          m_bOpenOutRaw ;           // flag forzatura lati aperti sempre fuori dal grezzo
+      double        m_dOpenMinSafe ;          // minima distanza di sicurezza di attacco su lato aperto
+      bool          m_bOptOffset ;            // flag per ottimizzazione numero di Offset necessari
+      bool          m_bOptOffsetCM ;          // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis
+      bool          m_bAssignFeed ;           // flag per controllo della Feed
+      double        m_dDiam_Prec ;            // diametro utensile per precedente svuotatura
+      double        m_dOffsetR_Prec ;         // offset radiale della svuotatura precedente
+      double        m_dSideStep_Prec ;        // side Step della svuotatura precedente
+      double        m_dLen_Prec ;             // Lunghezza del tool precedente
+      bool          m_bOrderStepZ ;           // parametro per ordinare gli step Extra per Z decrescente o meno
+      bool          m_bPocketPlane ;          // flag per svuotare solo la rimanenza sullo Step Extra
+      double        m_dOpenEdgeRad ;          // raggio di rientro per i lati aperti
 } ;