diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index 7b63d36..2d04a64 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/Pocketing.cpp b/Pocketing.cpp
index 88bd47b..4909a35 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -3741,7 +3741,7 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs,
          return true ;
    }
 
-  // recupero la curva originaria della svuotatura per verificare caso trapezoide 
+  // recupero la curva originaria della svuotatura (non allargata per lati aperti) per verificare caso trapezoide 
    int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
    PtrOwner<ICurveComposite> pCrvPocket( CloneCurveComposite( m_pGeomDB->GetGeoObj( nCrvId))) ;
    if ( IsNull( pCrvPocket))
@@ -4132,6 +4132,8 @@ bool
 Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtDir, double dPocketSize,  
                                 ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap)
 { 
+   bOptimizedTrap = false ;
+
    Vector3d vtExtr ; pCrvPocket->GetExtrusion( vtExtr) ;
   // eventuale approssimazione della curva con polyline per ottenere la stessa curva calcolata in ICurveComposite::IsATrapezoid
    if ( pCrvPocket->GetCurveCount() > 4) {
@@ -4161,9 +4163,9 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtD
       pCrvPocket->GetCurveTempProp( i, vnProp[i]) ;
 
   // verifico le dimensioni della svuotatura 
-   if ( ! vnProp[0] && abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL)
+   if ( vnProp[0] == 0  &&  abs( dPocketSize - m_TParams.m_dDiam) > EPS_SMALL)
       return false ;
-   if ( ! vnProp[1] && ! vnProp[3]) {
+   if ( vnProp[1] == 0  &&  vnProp[3] == 0) {
       double dLen0 = 0, dLen2 = 0 ;
       pCrvPocket->GetCurve( 0)->GetLength( dLen0) ;
       pCrvPocket->GetCurve( 2)->GetLength( dLen2) ;
@@ -4173,9 +4175,9 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtD
 
   // calcolo percorso di svuotatura
    double dYCoord = dPocketSize - 0.5 * m_TParams.m_dDiam ;
-   if ( vnProp[0]) 
+   if ( vnProp[0] != 0) 
       dYCoord -= GetOffsR() ; 
-   if ( vnProp[0] && vnProp[2])
+   if ( vnProp[0] != 0  &&  vnProp[2] != 0)
       dYCoord = 0.5 * dPocketSize ;   // se entrambi i lati paralleli sono aperti mi posiziono a metà della svuotatura 
 
    double dXCoordStart, dXCoordEnd ; 
@@ -4188,7 +4190,7 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtD
    Point3d ptStart( dXCoordStart, dYCoord) ;
    Point3d ptEnd( dXCoordEnd, dYCoord) ;
   
-   if ( AreSamePointEpsilon( ptStart, ptEnd, 500 * EPS_SMALL) && vnProp[0]) {      
+   if ( AreSamePointEpsilon( ptStart, ptEnd, 500 * EPS_SMALL)  &&  vnProp[0] != 0) {      
       Vector3d vtDir1, vtDir3 ; 
       pCrvPocket->GetCurve( 1)->GetStartDir( vtDir1) ;
       pCrvPocket->GetCurve( 3)->GetStartDir( vtDir3) ;
@@ -4213,7 +4215,7 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtD
          }
          
          pMCrv->AddPoint( ptS) ;
-         if ( vnProp[2])             
+         if ( vnProp[2] != 0)             
             pMCrv->AddLine( ptE) ;  
          else 
             pMCrv->AddLine( ptStart) ;
@@ -4228,11 +4230,15 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtD
          return true ;
 
      // aggiustamenti al percorso per rimuovere materiale residuo negli angoli
-      if ( vnProp[0]) {
-         if ( ! vnProp[3] && ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, true))         
-             return false ;
-         if ( ! vnProp[1] && ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, false))
+      if ( vnProp[0] != 0) {
+         if ( vnProp[3] == 0  &&  ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, true)) {
+            pMCrv->Clear() ;
             return false ;
+         }        
+         if ( vnProp[1] == 0  &&  ! AdjustTrapezoidSpiralForAngles( pMCrv, pCrvPocket, false)) {
+            pMCrv->Clear() ;
+            return false ;
+         }
       }     
    }  
   
@@ -4268,14 +4274,14 @@ Pocketing::CalcTrapezoidSpiralLocalFrame( ICurveComposite* pCrvPocket, const Vec
          break ;
       }
    }
-   if ( nBaseId != 0 && nBaseId != 1)
+   if ( nBaseId != 0  &&  nBaseId != 1)
       return false ;
 
   // imposto come lato iniziale per la curva uno dei lati paralleli a vtDir (possibilmente aperto)  
    int nProp0, nProp2 ;
    pCrvPocket->GetCurveTempProp( nBaseId, nProp0) ;
    pCrvPocket->GetCurveTempProp( nBaseId + 2, nProp2) ;
-   if ( ! nProp0 && nProp2)
+   if ( nProp0 == 0  &&  nProp2 != 0)
       pCrvPocket->ChangeStartPoint( nBaseId + 2) ;
    else
       pCrvPocket->ChangeStartPoint( nBaseId) ;
@@ -4293,11 +4299,10 @@ Pocketing::CalcTrapezoidSpiralLocalFrame( ICurveComposite* pCrvPocket, const Vec
 bool 
 Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite* pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize)
 {
-   int nCrvId = bStart ? 3 : 1 ;
-   int nProp ;
-
   // se open 
-   if ( pCrvPocket->GetCurveTempProp( nCrvId, nProp) && nProp) {
+   int nCrvId = ( bStart ? 3 : 1) ;
+   int nProp ;
+   if ( pCrvPocket->GetCurveTempProp( nCrvId, nProp)  &&  nProp != 0) {
       Point3d pt1, pt2 ;
       pCrvPocket->GetCurve( nCrvId)->GetStartPoint( pt1) ;
       pCrvPocket->GetCurve( nCrvId)->GetEndPoint( pt2) ;
@@ -4318,7 +4323,7 @@ Pocketing::CalcTrapezoidSpiralXCoord( const ICurveComposite* pCrvPocket, bool bS
          double dSinAlpha = ( vtRef ^ X_AX).Len()  ;
          if ( abs( dSinAlpha) <  EPS_SMALL) 
             return false ; 
-         dVal = 1 / dSinAlpha * ( dRad - dYCoord * dCosAlpha) ; 
+         dVal = 1.0 / dSinAlpha * ( dRad - dYCoord * dCosAlpha) ; 
       }
       else if ( dYCoord < dRad * dCosAlpha)
          dVal = sqrt( dRad * dRad - dYCoord * dYCoord) ; 
@@ -4356,7 +4361,7 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC
    pCrvPocket->GetCurve( 2)->GetStartPoint( ptTmp) ;
    double dPocketSize = ptTmp.y ;
 
-   int nCrvId = bStart ? 3 : 1 ;
+   int nCrvId = ( bStart ? 3 : 1) ;
    PtrOwner<ICurveLine> pLine( GetCurveLine( pCrvPocket->GetCurve( nCrvId)->Clone())) ;
    pLine->SimpleOffset( - 0.5 * m_TParams.m_dDiam - GetOffsR()) ;
 
@@ -4368,10 +4373,10 @@ Pocketing::AdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveC
 
    int nProp2 ;
   // lato opposto a quello di riferimento aperto 
-   if ( pCrvPocket->GetCurveTempProp( 2, nProp2) && nProp2) {
+   if ( pCrvPocket->GetCurveTempProp( 2, nProp2)  &&  nProp2 != 0) {
 
      // caso 1 : pLine ha un estremo sopra e uno sotto il percorso di svuotatura pMCrv
-      if ( ptP2.y < dYCoord && dYCoord < ptP1.y) {
+      if ( ptP2.y < dYCoord  &&  dYCoord < ptP1.y) {
 
         // creo tratto da ptP2 a ptP1
          pCompo->AddPoint( ptP2) ;
@@ -4487,7 +4492,7 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, ICurv
    Vector3d vtMainDir ;
    for ( int i = 0 ; i < pCompo->GetCurveCount() ; i++) {
       int nProp ;
-      if ( pCompo->GetCurveTempProp( i, nProp) && nProp == 0) {
+      if ( pCompo->GetCurveTempProp( i, nProp)  &&  nProp == 0) {
         // se non è lato aggiuntivo per la pulitura angoli recupero la sua direzione
          pCompo->GetCurve( i)->GetStartDir( vtMainDir) ;
          break ;
@@ -4502,13 +4507,13 @@ Pocketing::AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite* pCompo, ICurv
    ComputeTrapezoidSpiralLeadInLeadOut( pCompo, vtMainDir, false, vtTool, dDepth, bEndOutside) ; 
 
   // eventuale inversione della curva per partire sempre dall'esterno del grezzo 
-   if ( bEndOutside && ! bStartOutside)
+   if ( bEndOutside  &&  ! bStartOutside)
       pCompo->Invert() ;   
 
    nOutsideRaw = 0 ;
-   if ( bStartOutside && bEndOutside)
+   if ( bStartOutside  &&  bEndOutside)
       nOutsideRaw = 2 ; 
-   else if ( bStartOutside || bEndOutside) {
+   else if ( bStartOutside  ||  bEndOutside) {
       nOutsideRaw = 1 ; 
 
      // calcolo percorso di ritorno 
@@ -5267,12 +5272,12 @@ Pocketing::GetMidOfLongestOpenSide( const ICurveComposite* pCompo, Point3d& ptMi
             if ( pPrevCrv != nullptr  &&  pPrevCrv->GetTempProp() == 1) {
                Vector3d vtPrevEnd ;  pPrevCrv->GetEndDir( vtPrevEnd) ;
                Vector3d vtStart ;  pCrv->GetStartDir( vtStart) ;
-               dLenAgg += max( 0.25, vtPrevEnd * vtStart) * dLenPrev ;
+               dLenAgg += max( 0.4, vtPrevEnd * vtStart) * dLenPrev ;
             }
             if ( pNextCrv != nullptr  &&  pNextCrv->GetTempProp() == 1) {
                Vector3d vtEnd ;  pCrv->GetEndDir( vtEnd) ;
                Vector3d vtNextStart ;  pNextCrv->GetStartDir( vtNextStart) ;
-               dLenAgg += max( 0.25, vtEnd * vtNextStart) * dLenNext ;
+               dLenAgg += max( 0.4, vtEnd * vtNextStart) * dLenNext ;
             }
          }
         // entità corrente
diff --git a/Pocketing.h b/Pocketing.h
index b6faca7..bc4888a 100644
--- a/Pocketing.h
+++ b/Pocketing.h
@@ -103,8 +103,8 @@ class Pocketing : public Machining
                                       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 Vector3d& vtDir, double dPocketSize,  
+                                ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
       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) ;