diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index a6857b7..0ce7943 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/Sawing.cpp b/Sawing.cpp
index a2f3ff9..525e4ff 100644
--- a/Sawing.cpp
+++ b/Sawing.cpp
@@ -23,7 +23,8 @@
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EgkChainCurves.h"
+#include "/EgtDev/Include/EGkChainCurves.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkUserObjFactory.h"
 #include "/EgtDev/Include/EGnStringKeyVal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -1502,183 +1503,252 @@ Sawing::GenerateExtArcPv( const ICurveArc* pArc, const Vector3d& vtStaTool, cons
    }
 
   // contorno per parte di taglio completo
-   {
-      PtrOwner<ICurveArc> pIntArc( GetCurveArc( pArc->Clone())) ;
-      if ( IsNull( pIntArc)  ||  ! pIntArc->ChangeRadius( dIntRad))
-         return false ;
-      PtrOwner<ICurveArc> pExtArc( GetCurveArc( pArc->Clone())) ;
-      if ( IsNull( pExtArc)  ||  ! pExtArc->ChangeRadius( dExtRad))
-         return false ;
-      pExtArc->Invert() ;
-      PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
-      if ( IsNull( pLine))
-         return false ;
-      Point3d ptEnd ;
-      pIntArc->GetEndPoint( ptEnd) ;
-      Point3d ptStart ;
-      pExtArc->GetStartPoint( ptStart) ;
-      pLine->Set( ptEnd, ptStart) ;
-      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
-      if ( IsNull( pCompo)  ||
-           ! pCompo->AddCurve( Release( pIntArc))  ||
-           ! pCompo->AddCurve( Release( pLine))  ||
-           ! pCompo->AddCurve( Release( pExtArc))  ||
-           ! pCompo->Close())
-         return false ;
-      pCompo->Translate( dElev * vtCorr + Vector3d( 0, 0, 0.1)) ;
-      int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo)) ;
-      m_pGeomDB->SetName( nId, MCH_PV_CUT) ;
-      m_pGeomDB->SetMaterial( nId, LIME) ;
-   }
-
-  // contorno per parte iniziale di taglio
-   {
-     // direzione iniziale del taglio
-      Vector3d vtStaDir ;
-      pArc->GetStartDir( vtStaDir) ;
-     // punto iniziale e direzione radiale iniziale
-      Point3d ptStart ;
-      pArc->GetStartPoint( ptStart) ;
-      if ( ! AreHeadWorkOnSameSide())
-         ptStart += vtStaTool * m_TParams.m_dThick ;
-      Vector3d vtStaVer = pArc->GetStartVersor() ;
-     // punto prima di inizio
-      Point3d ptPre = ptStart - vtStaDir * dDeltaT ;
-     // punto fuori prima di inizio
-      Point3d ptOutPre = ptPre + vtStaVer * m_TParams.m_dThick ;
-     // punto fuori inizio
-      Point3d ptOut = ptStart + vtStaVer * ( dExtRad - dIntRad) ;
-     // linea base
-      PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
-      if ( IsNull( pLine1)  ||  ! pLine1->Set( ptStart, ptPre))
-         return false ;
-     // linea di spessore lama
-      PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
-      if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPre, ptOutPre))
-         return false ;
-     // arco
-      PtrOwner<ICurveArc> pExtArc( GetCurveArc( pArc->Clone())) ;
-      if ( IsNull( pExtArc)  ||  ! pExtArc->SetC2P( pArc->GetCenter(), ptOutPre, ptOut))
-         return false ;
-      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
-      if ( IsNull( pCompo)  ||
-           ! pCompo->AddCurve( Release( pLine1))  ||
-           ! pCompo->AddCurve( Release( pLine2))  ||
-           ! pCompo->AddCurve( Release( pExtArc))  ||
-           ! pCompo->Close())
-         return false ;
-      pCompo->Translate( dElev * vtCorr + Vector3d( 0, 0, 0.1)) ;
-      int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo)) ;
-      m_pGeomDB->SetName( nId, MCH_PV_PRE_CUT) ;
-      m_pGeomDB->SetMaterial( nId, BLUE) ;
-   }
-
-  // contorno per parte finale di taglio
-   {
-     // direzione finale del taglio
-      Vector3d vtEndDir ;
-      pArc->GetEndDir( vtEndDir) ;
-     // punto finale e direzione radiale finale
-      Point3d ptEnd ;
-      pArc->GetEndPoint( ptEnd) ;
-      Vector3d vtEndVer = ptEnd - pArc->GetCenter() ;
-      vtEndVer.Normalize() ;
-      if ( ! AreHeadWorkOnSameSide())
-         ptEnd += vtEndTool * m_TParams.m_dThick ;
-     // punto dopo fine
-      Point3d ptPost = ptEnd + vtEndDir * dDeltaT ;
-     // punto fuori dopo fine
-      Point3d ptOutPost = ptPost + vtEndVer * m_TParams.m_dThick ;
-     // punto fuori fine
-      Point3d ptOut = ptEnd + vtEndVer * ( dExtRad - dIntRad) ;
-     // linea base
-      PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
-      if ( IsNull( pLine1)  ||  ! pLine1->Set( ptEnd, ptPost))
-         return false ;
-     // linea di spessore lama
-      PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
-      if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPost, ptOutPost))
-         return false ;
-     // arco
-      PtrOwner<ICurveArc> pExtArc( GetCurveArc( pArc->Clone())) ;
-      if ( IsNull( pExtArc)  ||  ! pExtArc->SetC2P( pArc->GetCenter(), ptOutPost, ptOut))
-         return false ;
-      PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
-      if ( IsNull( pCompo)  ||
-           ! pCompo->AddCurve( Release( pLine1))  ||
-           ! pCompo->AddCurve( Release( pLine2))  ||
-           ! pCompo->AddCurve( Release( pExtArc))  ||
-           ! pCompo->Close())
-         return false ;
-      pCompo->Translate( dElev * vtCorr + Vector3d( 0, 0, 0.1)) ;
-      int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo)) ;
-      m_pGeomDB->SetName( nId, MCH_PV_POST_CUT) ;
-      m_pGeomDB->SetMaterial( nId, BLUE) ;
-   }
-
-
-#if 0
-  // rettangolo per parte di taglio completo
-   Point3d ptIni = pLine->GetStart() + dElev * vtCorr ;
-   Point3d ptEnd = pLine->GetEnd() + dElev * vtCorr ;
-   Vector3d vtToolH( vtTool.x, vtTool.y, 0) ;
-   vtToolH *= m_TParams.m_dThick / vtToolH.SqLen() ;
-   Point3d ptCross = ptEnd + vtToolH ;
-   Vector3d vtDZ( 0, 0, 0.1) ;
-   int nId = ExeCreateRectangle3P( nPxId, ptIni + vtDZ, ptCross + vtDZ, ptEnd + vtDZ, RTY_LOC) ;
+   PtrOwner<ICurveComposite> pCompo( GenerateExtArcPvTrueCut( pArc, dIntRad, dExtRad, 0)) ;
+   if ( IsNull( pCompo))
+      return false ;
+   pCompo->Translate( dElev * vtCorr + Vector3d( 0, 0, 0.1)) ;
+   int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo)) ;
    m_pGeomDB->SetName( nId, MCH_PV_CUT) ;
    m_pGeomDB->SetMaterial( nId, LIME) ;
 
-  // distanza XY tra centro e bordo taglio
-   double dDeltaT = (( dElev < 0.5 * m_TParams.m_dDiam) ? sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) : 0) ;
-  // direzione del taglio
-   Vector3d vtDir ;
-   pLine->GetStartDir( vtDir) ;
-
-  // rettangolo per parte parziale iniziale
-   int nId2 = ExeCreateRectangle3P( nPxId, ptIni - vtDir * dDeltaT, ptIni + vtToolH, ptIni, RTY_LOC) ;
-   // assegno nome e colore
+  // contorno per parte iniziale di taglio
+   PtrOwner<ICurveComposite> pCompo2( GenerateExtArcPvPreCut( pArc, dIntRad, dExtRad, dDeltaT, 0)) ;
+   if ( IsNull( pCompo2))
+      return false ;
+   pCompo2->Translate( dElev * vtCorr) ;
+   int nId2 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo2)) ;
    m_pGeomDB->SetName( nId2, MCH_PV_PRE_CUT) ;
    m_pGeomDB->SetMaterial( nId2, BLUE) ;
 
-  // rettangolo per parte parziale finale
-   int nId3 = ExeCreateRectangle3P( nPxId, ptEnd, ptCross + vtDir * dDeltaT, ptEnd + vtDir * dDeltaT, RTY_LOC) ;
-   // assegno nome e colore
+  // contorno per parte finale di taglio
+   PtrOwner<ICurveComposite> pCompo3( GenerateExtArcPvPostCut( pArc, dIntRad, dExtRad, dDeltaT, 0)) ;
+   if ( IsNull( pCompo3))
+      return false ;
+   pCompo3->Translate( dElev * vtCorr) ;
+   int nId3 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo3)) ;
    m_pGeomDB->SetName( nId3, MCH_PV_POST_CUT) ;
    m_pGeomDB->SetMaterial( nId3, BLUE) ;
 
-  // regione di taglio completo per nesting
+  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
    double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;
-   int nRId = ExeCreateSurfFrRectangle3P( nPxId, ptIni - vtDir * ( dDeltaT + dExtraL),
-                                          ptCross + vtDir * ( dDeltaT + dExtraL), ptEnd, RTY_LOC) ;
-   m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
-   m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
-  // regione di taglio ridotto per nesting (sono escluse le parti iniziale e finale)
-   const double EXTRALEN_R = 10 * EPS_SMALL ;
-   int nRrId = ExeCreateSurfFrRectangle3P( nPxId, ptIni - vtDir * EXTRALEN_R,
-                                           ptCross + vtDir * EXTRALEN_R, ptEnd, RTY_LOC) ;
+
+  // regione ridotta di taglio per nesting (escluse parti iniziali e finali)
+   PtrOwner<ICurveComposite> pCmpRr( GenerateExtArcPvTrueCut( pArc, dIntRad, dExtRad, dExtraL)) ;
+   if ( IsNull( pCmpRr))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRr ;
+   SfrCntrRr.AddCurve( Release( pCmpRr)) ;
+   ISurfFlatRegion* pSfrRr = SfrCntrRr.GetSurf() ;
+   if ( pSfrRr == nullptr)
+      return false ;
+   pSfrRr->Translate( dElev * vtCorr) ;
+   int nRrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRr) ;
    m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
    m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
-  // regione di ingresso al taglio (parte iniziale)
-   int nRsId = ExeCreateSurfFrRectangle3P( nPxId, ptIni - vtDir * ( dDeltaT + dExtraL),
-                                           ptIni + vtToolH, ptIni, RTY_LOC) ;
+
+  // regione di pre-taglio
+   PtrOwner<ICurveComposite> pCmpRs( GenerateExtArcPvPreCut( pArc, dIntRad, dExtRad, dDeltaT, dExtraL)) ;
+   if ( IsNull( pCmpRs))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRs ;
+   SfrCntrRs.AddCurve( Release( pCmpRs)) ;
+   ISurfFlatRegion* pSfrRs = SfrCntrRs.GetSurf() ;
+   if ( pSfrRs == nullptr)
+      return false ;
+   pSfrRs->Translate( dElev * vtCorr) ;
+   int nRsId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRs) ;
    m_pGeomDB->SetName( nRsId, MCH_PV_RLICUT) ;
    m_pGeomDB->SetMaterial( nRsId, INVISIBLE) ;
-  // regione di uscita dal taglio (parte finale)
-   int nReId = ExeCreateSurfFrRectangle3P( nPxId, ptEnd, ptCross + vtDir * ( dDeltaT + dExtraL),
-                                           ptEnd + vtDir * ( dDeltaT + dExtraL) , RTY_LOC) ;
+
+  // regione di post-taglio
+   PtrOwner<ICurveComposite> pCmpRe( GenerateExtArcPvPostCut( pArc, dIntRad, dExtRad, dDeltaT, dExtraL)) ;
+   if ( IsNull( pCmpRe))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRe ;
+   SfrCntrRe.AddCurve( Release( pCmpRe)) ;
+   ISurfFlatRegion* pSfrRe = SfrCntrRe.GetSurf() ;
+   if ( pSfrRe == nullptr)
+      return false ;
+   pSfrRe->Translate( dElev * vtCorr) ;
+   int nReId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRe) ;
    m_pGeomDB->SetName( nReId, MCH_PV_RLOCUT) ;
    m_pGeomDB->SetMaterial( nReId, INVISIBLE) ;
 
+  // regione completa (unione delle tre precedenti)
+   int nRId = m_pGeomDB->Copy( nRrId, GDB_ID_NULL, nRrId, GDB_BEFORE) ;
+   m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
+   m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
+   if ( nRId == GDB_ID_NULL)
+      return false ;
+   if ( ! ExeSurfFrAdd( nRId, nRsId)  ||  ! ExeSurfFrAdd( nRId, nReId))
+      return false ;
+
   // salvo in info del gruppo la larghezza XY del taglio e la distanza XY tra centro e bordo taglio
-   m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_WT, vtToolH.LenXY()) ;
+   m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_WT, dExtRad - dIntRad) ;
    m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_DT, dDeltaT) ;
 
-#endif
-
    return true ;
 }
 
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateExtArcPvTrueCut( const ICurveArc* pArc, double dIntRad, double dExtRad, double dSafety)
+{
+  // arco interno
+   PtrOwner<ICurveArc> pIntArc( GetCurveArc( pArc->Clone())) ;
+   if ( IsNull( pIntArc)  ||  ! pIntArc->ChangeRadius( dIntRad))
+      return nullptr ;
+  // arco esterno
+   PtrOwner<ICurveArc> pExtArc( GetCurveArc( pArc->Clone())) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->ChangeRadius( dExtRad + dSafety))
+      return nullptr ;
+   pExtArc->Invert() ;
+  // linea di raccordo
+   PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
+   if ( IsNull( pLine))
+      return nullptr ;
+   Point3d ptEnd ;
+   pIntArc->GetEndPoint( ptEnd) ;
+   Point3d ptStart ;
+   pExtArc->GetStartPoint( ptStart) ;
+   pLine->Set( ptEnd, ptStart) ;
+  // composizione
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+         ! pCompo->AddCurve( Release( pIntArc))  ||
+         ! pCompo->AddCurve( Release( pLine))  ||
+         ! pCompo->AddCurve( Release( pExtArc))  ||
+         ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateExtArcPvPreCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                double dDeltaT, double dSafety)
+{
+  // direzione iniziale del taglio
+   Vector3d vtStaDir ;
+   pArc->GetStartDir( vtStaDir) ;
+  // direzione radiale iniziale
+   Vector3d vtStaVer = pArc->GetStartVersor() ;
+  // punto iniziale
+   Point3d ptStart ;
+   pArc->GetStartPoint( ptStart) ;
+   if ( ! AreHeadWorkOnSameSide())
+      ptStart -= vtStaVer * m_TParams.m_dThick ;
+  // punto prima di inizio
+   Point3d ptPre = ptStart - vtStaDir * dDeltaT ;
+  // punto fuori prima di inizio
+   Point3d ptOutPre = ptPre + vtStaVer * m_TParams.m_dThick ;
+  // punto fuori inizio
+   Point3d ptOut = ptStart + vtStaVer * ( dExtRad - dIntRad) ;
+  // linea di spessore lama
+   PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
+   if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPre, ptOutPre))
+      return nullptr ;
+  // arco
+   PtrOwner<ICurveArc> pExtArc( CreateCurveArc()) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->SetC2P( pArc->GetCenter(), ptOutPre, ptOut))
+      return nullptr ;
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+        ! pCompo->AddCurve( Release( pLine2))  ||
+        ! pCompo->AddCurve( Release( pExtArc)))
+      return nullptr ;
+  // eventuale offset per sicurezza
+   if ( dSafety > EPS_SMALL) {
+     double dOffs = ( pArc->GetAngCenter() > 0 ? dSafety : - dSafety) ;
+     if ( ! pCompo->SimpleOffset( dOffs, ICurve::OFF_EXTEND))
+        return nullptr ;
+   }
+  // linea base
+   Point3d ptJoin ;
+   pCompo->GetStartPoint( ptJoin) ;
+   PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
+   if ( IsNull( pLine1)  ||  ! pLine1->Set( ptStart, ptJoin))
+      return nullptr ;
+   if ( ! pCompo->AddCurve( Release( pLine1), false))
+      return nullptr ;
+  // chiusura
+   if ( ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateExtArcPvPostCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                 double dDeltaT, double dSafety)
+{
+  // direzione finale del taglio
+   Vector3d vtEndDir ;
+   pArc->GetEndDir( vtEndDir) ;
+  // punto finale e direzione radiale finale
+   Point3d ptEnd ;
+   pArc->GetEndPoint( ptEnd) ;
+   Vector3d vtEndVer = ptEnd - pArc->GetCenter() ;
+   vtEndVer.Normalize() ;
+   if ( ! AreHeadWorkOnSameSide())
+      ptEnd -= vtEndVer * m_TParams.m_dThick ;
+  // punto dopo fine
+   Point3d ptPost = ptEnd + vtEndDir * dDeltaT ;
+  // punto fuori dopo fine
+   Point3d ptOutPost = ptPost + vtEndVer * m_TParams.m_dThick ;
+  // punto fuori fine
+   Point3d ptOut = ptEnd + vtEndVer * ( dExtRad - dIntRad) ;
+  // linea di spessore lama
+   PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
+   if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPost, ptOutPost))
+      return nullptr ;
+  // arco
+   PtrOwner<ICurveArc> pExtArc( CreateCurveArc()) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->SetC2P( pArc->GetCenter(), ptOutPost, ptOut))
+      return nullptr ;
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+        ! pCompo->AddCurve( Release( pLine2))  ||
+        ! pCompo->AddCurve( Release( pExtArc)))
+      return nullptr ;
+  // eventuale offset per sicurezza
+   if ( dSafety > EPS_SMALL) {
+     double dOffs = ( pArc->GetAngCenter() > 0 ? - dSafety : dSafety) ;
+     if ( ! pCompo->SimpleOffset( dOffs, ICurve::OFF_EXTEND))
+        return nullptr ;
+   }
+  // linea base
+   Point3d ptJoin ;
+   pCompo->GetStartPoint( ptJoin) ;
+   PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
+   if ( IsNull( pLine1)  ||  ! pLine1->Set( ptEnd, ptJoin))
+      return nullptr ;
+   if ( ! pCompo->AddCurve( Release( pLine1), false))
+      return nullptr ;
+  // chiusura
+   if ( ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, const Vector3d& vtMidTool,
@@ -1698,8 +1768,6 @@ Sawing::GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, cons
    double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
-   if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
-      dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
 
   // angolo al centro massimo
    const double MAX_ANG_CEN = 150.0 ;
@@ -2011,7 +2079,8 @@ Sawing::ProcessIntArc( const ICurve* pCrvP, const ICurveArc* pArcC, const ICurve
 
   // Se richiesto Preview
    if ( nPvId != GDB_ID_NULL) {
-      if ( ! GenerateExtArcPv( Get( pArc), vtStaTool, vtMidTool, vtEndTool, vtStaCorr, dElev, dExtraCut, sName, nPvId))
+      if ( ! GenerateIntArcPv( Get( pArc), vtStaTool, vtMidTool, vtEndTool,
+                               vtStaCorr, vtMidCorr, vtEndCorr, dElev, dExtraCut, sName, nPvId))
          return false ;
    }
 
@@ -2028,6 +2097,285 @@ Sawing::ProcessIntArc( const ICurve* pCrvP, const ICurveArc* pArcC, const ICurve
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+Sawing::GenerateIntArcPv( const ICurveArc* pArc,
+                          const Vector3d& vtStaTool, const Vector3d& vtMidTool, const Vector3d& vtEndTool,
+                          const Vector3d& vtStaCorr, const Vector3d& vtMidCorr, const Vector3d& vtEndCorr,
+                          double dElev, double dExtraCut, const string& sName, int nPvId)
+{
+  // creo gruppo per anteprima di lavorazione dell'arco
+   int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPvId, Frame3d()) ;
+   if ( nPxId == GDB_ID_NULL)
+      return false ;
+   m_pGeomDB->SetName( nPxId, sName) ;
+   m_pGeomDB->SetMaterial( nPxId, BLUE) ;
+
+  // disabilito eventuale registrazione comandi EXE (riabilitazione automatica)
+   CmdLogOff cmdLogOff ;
+
+  // lunghezza taglio parziale
+   double dDeltaT = (( dElev < 0.5 * m_TParams.m_dDiam) ? sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) : 0) ;
+
+  // seno e coseno dell'angolo di sbndamento
+   double dSinA = sqrt( vtStaCorr.x * vtStaCorr.x + vtStaCorr.y * vtStaCorr.y) ;
+   double dCosA = vtStaCorr.z ;
+
+  // scostamenti da linea di lavoro (testa e lavoro sono da parti opposte)
+   double dDeltaInt = dElev * dSinA / dCosA ;
+   double dDeltaExt = m_TParams.m_dThick * dCosA ;
+
+  // larghezza inclinata della lama
+   double dSlantThick = m_TParams.m_dThick / dCosA ;
+
+  // contorno per parte di taglio completo
+   PtrOwner<ICurveComposite> pCompo( GenerateIntArcPvTrueCut( pArc, dDeltaInt, dDeltaExt, 0)) ;
+   if ( IsNull( pCompo))
+      return false ;
+   pCompo->Translate( dElev * Z_AX + Vector3d( 0, 0, 0.1)) ;
+   int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo)) ;
+   m_pGeomDB->SetName( nId, MCH_PV_CUT) ;
+   m_pGeomDB->SetMaterial( nId, LIME) ;
+
+  // contorno per parte iniziale di taglio
+   PtrOwner<ICurveComposite> pCompo2( GenerateIntArcPvPreCut( pArc, dDeltaInt, dDeltaExt, dSlantThick, dDeltaT, 0)) ;
+   if ( IsNull( pCompo2))
+      return false ;
+   pCompo2->Translate( dElev * Z_AX) ;
+   int nId2 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo2)) ;
+   m_pGeomDB->SetName( nId2, MCH_PV_PRE_CUT) ;
+   m_pGeomDB->SetMaterial( nId2, BLUE) ;
+
+  // contorno per parte finale di taglio
+   PtrOwner<ICurveComposite> pCompo3( GenerateIntArcPvPostCut( pArc, dDeltaInt, dDeltaExt, dSlantThick, dDeltaT, 0)) ;
+   if ( IsNull( pCompo3))
+      return false ;
+   pCompo3->Translate( dElev * Z_AX) ;
+   int nId3 = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, Release( pCompo3)) ;
+   m_pGeomDB->SetName( nId3, MCH_PV_POST_CUT) ;
+   m_pGeomDB->SetMaterial( nId3, BLUE) ;
+
+  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
+   double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;
+
+  // regione ridotta di taglio per nesting (escluse parti iniziali e finali)
+   PtrOwner<ICurveComposite> pCmpRr( GenerateIntArcPvTrueCut( pArc, dDeltaInt, dDeltaExt, dExtraL)) ;
+   if ( IsNull( pCmpRr))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRr ;
+   SfrCntrRr.AddCurve( Release( pCmpRr)) ;
+   ISurfFlatRegion* pSfrRr = SfrCntrRr.GetSurf() ;
+   if ( pSfrRr == nullptr)
+      return false ;
+   pSfrRr->Translate( dElev * Z_AX) ;
+   int nRrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRr) ;
+   m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
+   m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
+
+  // regione di pre-taglio
+   PtrOwner<ICurveComposite> pCmpRs( GenerateIntArcPvPreCut( pArc, dDeltaInt, dDeltaExt, dSlantThick, dDeltaT, dExtraL)) ;
+   if ( IsNull( pCmpRs))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRs ;
+   SfrCntrRs.AddCurve( Release( pCmpRs)) ;
+   ISurfFlatRegion* pSfrRs = SfrCntrRs.GetSurf() ;
+   if ( pSfrRs == nullptr)
+      return false ;
+   pSfrRs->Translate( dElev * Z_AX) ;
+   int nRsId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRs) ;
+   m_pGeomDB->SetName( nRsId, MCH_PV_RLICUT) ;
+   m_pGeomDB->SetMaterial( nRsId, INVISIBLE) ;
+
+  // regione di post-taglio
+   PtrOwner<ICurveComposite> pCmpRe( GenerateIntArcPvPostCut( pArc, dDeltaInt, dDeltaExt, dSlantThick, dDeltaT, dExtraL)) ;
+   if ( IsNull( pCmpRe))
+      return false ;
+   SurfFlatRegionByContours SfrCntrRe ;
+   SfrCntrRe.AddCurve( Release( pCmpRe)) ;
+   ISurfFlatRegion* pSfrRe = SfrCntrRe.GetSurf() ;
+   if ( pSfrRe == nullptr)
+      return false ;
+   pSfrRe->Translate( dElev * Z_AX) ;
+   int nReId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPxId, pSfrRe) ;
+   m_pGeomDB->SetName( nReId, MCH_PV_RLOCUT) ;
+   m_pGeomDB->SetMaterial( nReId, INVISIBLE) ;
+
+  // regione completa (unione delle tre precedenti)
+   int nRId = m_pGeomDB->Copy( nRrId, GDB_ID_NULL, nRrId, GDB_BEFORE) ;
+   m_pGeomDB->SetName( nRId, MCH_PV_RCUT) ;
+   m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
+   if ( nRId == GDB_ID_NULL)
+      return false ;
+   if ( ! ExeSurfFrAdd( nRId, nRsId)  ||  ! ExeSurfFrAdd( nRId, nReId))
+      return false ;
+
+  // salvo in info del gruppo la larghezza XY del taglio e la distanza XY tra centro e bordo taglio
+   m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_WT, dDeltaInt + dDeltaExt) ;
+   m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_DT, dDeltaT) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateIntArcPvTrueCut( const ICurveArc* pArc, double dDeltaInt, double dDeltaExt, double dSafety)
+{
+  // arco interno
+   PtrOwner<ICurveArc> pIntArc( GetCurveArc( pArc->Clone())) ;
+   if ( IsNull( pIntArc)  ||  ! pIntArc->ChangeRadius( pArc->GetRadius() - dDeltaInt - dSafety))
+      return nullptr ;
+  // arco esterno
+   PtrOwner<ICurveArc> pExtArc( GetCurveArc( pArc->Clone())) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->ChangeRadius( pArc->GetRadius() + dDeltaExt))
+      return nullptr ;
+   pExtArc->Invert() ;
+  // linea di raccordo
+   PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
+   if ( IsNull( pLine))
+      return nullptr ;
+   Point3d ptEnd ;
+   pIntArc->GetEndPoint( ptEnd) ;
+   Point3d ptStart ;
+   pExtArc->GetStartPoint( ptStart) ;
+   pLine->Set( ptEnd, ptStart) ;
+  // composizione
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+         ! pCompo->AddCurve( Release( pIntArc))  ||
+         ! pCompo->AddCurve( Release( pLine))  ||
+         ! pCompo->AddCurve( Release( pExtArc))  ||
+         ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateIntArcPvPreCut( const ICurveArc* pArc, double dDeltaInt, double dDeltaExt,
+                                double dSlantThick, double dDeltaT, double dSafety)
+{
+  // direzione iniziale del taglio
+   Vector3d vtStaDir ;
+   pArc->GetStartDir( vtStaDir) ;
+  // direzione radiale iniziale
+   Vector3d vtStaVer = pArc->GetStartVersor() ;
+  // punto iniziale
+   Point3d ptStart ;
+   pArc->GetStartPoint( ptStart) ;
+   ptStart -= vtStaVer * dDeltaInt ;
+  // punto prima di inizio
+   Point3d ptPre = ptStart - vtStaDir * dDeltaT ;
+  // punto fuori prima di inizio
+   Point3d ptOutPre = ptPre + vtStaVer * dSlantThick ;
+  // punto fuori inizio
+   Point3d ptOut = ptStart + vtStaVer * ( dDeltaInt + dDeltaExt) ;
+  // linea base
+   PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
+   if ( IsNull( pLine1)  ||  ! pLine1->Set( ptStart, ptPre))
+      return nullptr ;
+  // linea di spessore lama
+   PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
+   if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPre, ptOutPre))
+      return nullptr ;
+  // composita delle due linee
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+        ! pCompo->AddCurve( Release( pLine1))  ||
+        ! pCompo->AddCurve( Release( pLine2)))
+      return nullptr ;
+  // eventuale offset per sicurezza
+   if ( dSafety > EPS_SMALL) {
+     double dOffs = ( pArc->GetAngCenter() > 0 ? dSafety : - dSafety) ;
+     if ( ! pCompo->SimpleOffset( dOffs, ICurve::OFF_EXTEND))
+        return nullptr ;
+   }
+  // arco
+   Point3d ptJoin ;
+   pCompo->GetEndPoint( ptJoin) ;
+   PtrOwner<ICurveArc> pExtArc( CreateCurveArc()) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->Set2PVN( ptOut, ptJoin, - vtStaDir, Z_AX)  ||
+        ! pExtArc->Invert())
+      return nullptr ;
+   if ( ! pCompo->AddCurve( Release( pExtArc)))
+      return nullptr ;
+  // chiusura
+   if ( ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
+//----------------------------------------------------------------------------
+ICurveComposite*
+Sawing::GenerateIntArcPvPostCut( const ICurveArc* pArc, double dDeltaInt, double dDeltaExt,
+                                 double dSlantThick, double dDeltaT, double dSafety)
+{
+  // direzione finale del taglio
+   Vector3d vtEndDir ;
+   pArc->GetEndDir( vtEndDir) ;
+  // punto finale e direzione radiale finale
+   Point3d ptEnd ;
+   pArc->GetEndPoint( ptEnd) ;
+   Vector3d vtEndVer = ptEnd - pArc->GetCenter() ;
+   vtEndVer.Normalize() ;
+   ptEnd -= vtEndVer * dDeltaInt ;
+  // punto dopo fine
+   Point3d ptPost = ptEnd + vtEndDir * dDeltaT ;
+  // punto fuori dopo fine
+   Point3d ptOutPost = ptPost + vtEndVer * dSlantThick ;
+  // punto fuori fine
+   Point3d ptOut = ptEnd + vtEndVer * ( dDeltaInt + dDeltaExt) ;
+  // linea base
+   PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
+   if ( IsNull( pLine1)  ||  ! pLine1->Set( ptEnd, ptPost))
+      return nullptr ;
+  // linea di spessore lama
+   PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
+   if ( IsNull( pLine2)  ||  ! pLine2->Set( ptPost, ptOutPost))
+      return nullptr ;
+   PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+   if ( IsNull( pCompo)  ||
+        ! pCompo->AddCurve( Release( pLine1))  ||
+        ! pCompo->AddCurve( Release( pLine2)))
+      return nullptr ;
+  // eventuale offset per sicurezza
+   if ( dSafety > EPS_SMALL) {
+     double dOffs = ( pArc->GetAngCenter() > 0 ? - dSafety : dSafety) ;
+     if ( ! pCompo->SimpleOffset( dOffs, ICurve::OFF_EXTEND))
+        return nullptr ;
+   }
+  // arco
+   Point3d ptJoin ;
+   pCompo->GetEndPoint( ptJoin) ;
+   PtrOwner<ICurveArc> pExtArc( CreateCurveArc()) ;
+   if ( IsNull( pExtArc)  ||  ! pExtArc->Set2PVN( ptOut, ptJoin, vtEndDir, Z_AX)  ||
+        ! pExtArc->Invert())
+      return nullptr ;
+   if ( ! pCompo->AddCurve( Release( pExtArc)))
+      return nullptr ;
+  // chiusura
+   if ( ! pCompo->Close())
+      return nullptr ;
+  // impongo senso CCW
+   double dArea ;
+   if ( ! pCompo->GetAreaXY( dArea))
+      return nullptr ;
+   if ( dArea < 0)
+      pCompo->Invert() ;
+   return Release( pCompo) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Sawing::GenerateIntArcCl( const ICurveArc* pArc,
@@ -2047,8 +2395,6 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc,
    double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
-   if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
-      dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
 
   // angolo al centro massimo
    const double MAX_ANG_CEN = 150.0 ;
diff --git a/Sawing.h b/Sawing.h
index 3f1915a..8a75b5f 100644
--- a/Sawing.h
+++ b/Sawing.h
@@ -20,6 +20,7 @@
 class ICurve ;
 class ICurveLine ;
 class ICurveArc ;
+class ICurveComposite ;
 
 //----------------------------------------------------------------------------
 class Sawing : public Machining
@@ -77,12 +78,28 @@ class Sawing : public Machining
       bool GenerateExtArcPv( const ICurveArc* pArc, const Vector3d& vtStaTool, const Vector3d& vtMidTool,
                              const Vector3d& vtEndTool, const Vector3d& vtCorr,
                              double dElev, double dExtraCut, const string& sName, int nPvId) ;
+      ICurveComposite* GenerateExtArcPvTrueCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                                double dSafety) ;
+      ICurveComposite* GenerateExtArcPvPreCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                               double dDeltaT, double dSafety) ;
+      ICurveComposite* GenerateExtArcPvPostCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                                double dDeltaT, double dSafety) ;
       bool GenerateExtArcCl( const ICurveArc* pArc, const Vector3d& vtStaTool, const Vector3d& vtMidTool,
                              const Vector3d& vtEndTool, const Vector3d& vtCorr,
                              double dElev, double dExtraCut, const string& sName, int nClId) ;
       bool ProcessIntArc( const ICurve* pCrvP, const ICurveArc* pArcC, const ICurve* pCrvN,
                           double dDepth, double dExtraCut, bool bIsFirst, bool bIsLast,
                           const string& sName, int nPvId, int nClId) ;
+      bool GenerateIntArcPv( const ICurveArc* pArc,
+                             const Vector3d& vtStaTool, const Vector3d& vtMidTool, const Vector3d& vtEndTool,
+                             const Vector3d& vtStaCorr, const Vector3d& vtMidCorr, const Vector3d& vtEndCorr,
+                             double dElev, double dExtraCut, const string& sName, int nPvId) ;
+      ICurveComposite* GenerateIntArcPvTrueCut( const ICurveArc* pArc, double dDeltaInt, double dDeltaExt,
+                                                double dSafety) ;
+      ICurveComposite* GenerateIntArcPvPreCut( const ICurveArc* pArc, double dDeltaInt, double dDeltaExt,
+                                               double dSlantThick, double dDeltaT, double dSafety) ;
+      ICurveComposite* GenerateIntArcPvPostCut( const ICurveArc* pArc, double dIntRad, double dExtRad,
+                                                double dSlantThick, double dDeltaT, double dSafety) ;
       bool GenerateIntArcCl( const ICurveArc* pArc,
                              const Vector3d& vtStaTool, const Vector3d& vtMidTool, const Vector3d& vtEndTool,
                              const Vector3d& vtStaCorr, const Vector3d& vtMidCorr, const Vector3d& vtEndCorr,