diff --git a/BiArcs.cpp b/BiArcs.cpp
index ab1e60b..f65e8bb 100644
--- a/BiArcs.cpp
+++ b/BiArcs.cpp
@@ -94,7 +94,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       pBiArc.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, 0.5)) ;
    }
    else {
-      CurveArc* pArc = GetBasicCurveArc( Get( pJCrv)) ;
+      CurveArc* pArc = GetBasicCurveArc( pJCrv) ;
       if ( pArc == nullptr)
          return nullptr ;
       double dU = - 1 ;
@@ -137,7 +137,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
    for ( bool bPnt = PL.GetFirstPoint( ptP) ;
          bPnt ;
          bPnt = PL.GetNextPoint( ptP)) {
-      DistPointCurve dstPC( ptP, *Get( pBiArc)) ;
+      DistPointCurve dstPC( ptP, *pBiArc) ;
       double dSqDistPC ;
       if ( dstPC.GetSqDist( dSqDistPC)  &&  dSqDistPC > dSqDist)
          dSqDist = dSqDistPC ;
diff --git a/CurveAux.cpp b/CurveAux.cpp
index d6c1fe9..3adb9f2 100644
--- a/CurveAux.cpp
+++ b/CurveAux.cpp
@@ -442,8 +442,8 @@ ArcToBezierCurve( const ICurve* pCrv)
             return false ;
       }
      // copio estrusione e spessore
-      CopyExtrusion( pArc, Get( pCrvCompo)) ;
-      CopyThickness( pArc, Get( pCrvCompo)) ;
+      CopyExtrusion( pArc, pCrvCompo) ;
+      CopyThickness( pArc, pCrvCompo) ;
      // restituisco la curva
       return Release( pCrvCompo) ;
    }
@@ -494,8 +494,8 @@ CurveToArcsPerpExtrCurve( const ICurve* pCrv, double dLinTol, double dAngTolDeg)
       if ( ! pCopyCC->FromPolyArc( PA))
          return nullptr ;
      // copio estrusione e spessore
-      CopyExtrusion( pCrv, Get( pCopyCC)) ;
-      CopyThickness( pCrv, Get( pCopyCC)) ;
+      CopyExtrusion( pCrv, pCopyCC) ;
+      CopyThickness( pCrv, pCopyCC) ;
       return Release( pCopyCC) ;
    }
   // altrimenti devo solo copiarla
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index 59b038e..92f6f1a 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -20,12 +20,15 @@
 #include "CurveArc.h"
 #include "CurveBezier.h"
 #include "PolygonPlane.h"
+#include "SurfFlatRegion.h"
 #include "GeoConst.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EgkArcSpecial.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <algorithm>
@@ -1185,7 +1188,7 @@ CurveComposite::GetParamAtLength( double dLen, double& dU) const
          if ( ! (*Iter)->GetParamAtLength( dLenToGo, dULen))
             return false ;
          dU += dULen ; 
-         break ;
+         return true ;
       }
      // altrimenti
       else {
@@ -1198,7 +1201,7 @@ CurveComposite::GetParamAtLength( double dLen, double& dU) const
       }
    }
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -2414,7 +2417,7 @@ CurveComposite::ArcsToBezierCurves( void)
          }
         // altrimenti è una curva composita
          else {
-            CurveComposite* pCC = GetBasicCurveComposite( Get( pNewCrv)) ;
+            CurveComposite* pCC = GetBasicCurveComposite( pNewCrv) ;
             if ( pCC == nullptr)
                return false ;
            // inserisco le curve prima dell'arco
@@ -2458,7 +2461,7 @@ CurveComposite::ArcsBezierCurvesToArcsPerpExtr( double dLinTol, double dAngTolDe
          }
         // altrimenti è una curva composita
          else {
-            CurveComposite* pCC = GetBasicCurveComposite( Get( pNewCrv)) ;
+            CurveComposite* pCC = GetBasicCurveComposite( pNewCrv) ;
             if ( pCC == nullptr)
                return false ;
            // inserisco le curve prima dell'originale
@@ -2628,4 +2631,149 @@ CurveComposite::MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTo
    }
   // nessuna fusione
    return false ;
-}
\ No newline at end of file
+}
+
+//----------------------------------------------------------------------------
+bool
+SplitTopBottomArcs( CurveComposite& cCompo)
+{
+   int i = 0 ;
+   const ICurve* pCrv = cCompo.GetCurve( i) ;
+   while ( pCrv != nullptr) {
+      if ( pCrv->GetType() == CRV_ARC) {
+         const CurveArc* pArc = GetBasicCurveArc( pCrv) ;
+        // determino la rotazione angolare dall'inizio alle direzioni destra e sinistra
+         double dAng1, dAng2 ;
+         bool bDet ;
+         pArc->GetStartVersor().GetRotation( X_AX, Z_AX, dAng1, bDet) ;
+         pArc->GetStartVersor().GetRotation( - X_AX, Z_AX, dAng2, bDet) ;
+        // oriento queste rotazioni come l'angolo al centro dell'arco
+         if ( pArc->GetAngCenter() > 0) {
+            if ( dAng1 < 0)
+               dAng1 += ANG_FULL ;
+            if ( dAng2 < 0)
+               dAng2 += ANG_FULL ;
+         }
+         else {
+            if ( dAng1 > 0)
+               dAng1 -= ANG_FULL ;
+            if ( dAng2 > 0)
+               dAng2 -= ANG_FULL ;
+         }
+        // le ordino in senso crescente di ampiezza assoluta
+         if ( abs( dAng1) > abs( dAng2))
+            swap( dAng1, dAng2) ;
+        // verifico se la prima di queste rotazioni è compresa nell'arco
+         if ( abs( dAng1) > EPS_ANG_SMALL  &&  abs( dAng1) < abs( pArc->GetAngCenter()) - EPS_ANG_SMALL) {
+            cCompo.AddJoint( i + dAng1 / pArc->GetAngCenter()) ;
+         }
+        // verifico la seconda
+         else if ( abs( dAng2) > EPS_ANG_SMALL  &&  abs( dAng2) < abs( pArc->GetAngCenter()) - EPS_ANG_SMALL) {
+            cCompo.AddJoint( i + dAng2 / pArc->GetAngCenter()) ;
+         }
+      }  
+     // passo alla successiva
+      pCrv = cCompo.GetCurve( ++i) ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CurveComposite::RemoveUndercutOnY( double dLinTol, double dAngTolDeg)
+{
+  // verifico sia una curva che giace nel piano XY e con vettore estrusione nullo o Z
+   BBox3d b3Box ;
+   if ( ! GetLocalBBox( b3Box)  ||  ( b3Box.GetMax().z - b3Box.GetMin().z) > dLinTol)
+      return false ;
+   if ( ! m_VtExtr.IsSmall()  &&  ! AreSameVectorApprox( m_VtExtr, Z_AX))
+      return false ;
+  // ne faccio una copia
+   CurveComposite ccCopy ;
+   if ( ! ccCopy.CopyFrom( this))
+      return false ;
+  // eventuali modifiche deve essere formata solo da archi e rette
+   if ( ! ccCopy.ArcsBezierCurvesToArcsPerpExtr( dLinTol, dAngTolDeg))
+      return false ;
+  // divido gli archi in sopra e sotto
+   if ( ! SplitTopBottomArcs( ccCopy))
+      return false ;
+  // creo la regione unione delle regioni sottese ad ogni curva rispetto ad un Y inferiore al minimo del box
+   SurfFlatRegion SfrTot ;
+   const double DELTA_Y = 10 ;
+   double dYmin = b3Box.GetMin().y - DELTA_Y ;
+   PtrOwner<ICurve> pCrv ;
+   while ( pCrv.Set( ccCopy.RemoveFirstOrLastCurve( false))) {
+     // se linea verticale non sottende alcunché, quindi la salto
+      if ( pCrv->GetType() == CRV_LINE) {
+         const CurveLine* pLine = GetBasicCurveLine( pCrv) ;
+         if ( abs( pLine->GetStart().x - pLine->GetEnd().x) < EPS_SMALL) {
+            pCrv.Reset() ;
+            continue ;
+         }
+      }
+     // creo la regione sottesa dalla curva
+      PtrOwner<CurveComposite> pCompo( CreateBasicCurveComposite()) ;
+      if ( IsNull( pCompo))
+         return false ;
+      pCompo->AddCurve( Release( pCrv)) ;
+      Point3d ptStart, ptEnd ;
+      pCompo->GetStartPoint( ptStart) ;
+      pCompo->GetEndPoint( ptEnd) ;
+      if ( ptStart.x < ptEnd.x) {
+         swap( ptStart, ptEnd) ;
+         pCompo->Invert() ;
+      }
+      pCompo->AddLine( Point3d( ptEnd.x, dYmin, ptEnd.z)) ;
+      pCompo->AddLine( Point3d( ptStart.x, dYmin, ptStart.z)) ;
+      pCompo->Close() ;
+      SurfFlatRegion Sfr ;
+      Sfr.AddExtLoop( Release( pCompo)) ;
+      if ( ! Sfr.IsValid())
+         return false ;
+     // la unisco alla regione complessiva
+      if ( ! SfrTot.IsValid())
+         SfrTot = Sfr ;
+      else {
+         if ( ! SfrTot.Add( Sfr))
+            return false ;
+      }
+   }
+  // recupero il contorno esterno della regione
+   PtrOwner<ICurve> pOutLoop( SfrTot.GetLoop( 0, 0)) ;
+   if ( IsNull( pOutLoop))
+      return false ;
+  // elimino le parti sotto il minimo del box
+   // box della parte da eliminare
+   double dWidth = b3Box.GetMax().x - b3Box.GetMin().x + 20 * EPS_SMALL ;
+   double dLen = DELTA_Y + 10 * EPS_SMALL ;
+   PtrOwner<ISurfFlatRegion> pSfrCut( GetSurfFlatRegionRectangle( dWidth, dLen)) ;
+   if ( IsNull( pSfrCut))
+      return false ;
+   pSfrCut->Translate( b3Box.GetMin() - Point3d( 10 * EPS_SMALL, dLen, 0)) ;
+   // calcolo la classificazione della curva rispetto alla regione
+   CRVCVECTOR ccClass ;
+   if ( ! pSfrCut->GetCurveClassification( *pOutLoop, ccClass))
+      return false ;
+  // determino gli intervalli di curva da conservare
+   Intervals inOk ;
+   for ( auto& ccOne : ccClass) {
+      if ( ccOne.nClass == CRVC_OUT)
+         inOk.Add( ccOne.dParS, ccOne.dParE) ;
+   }
+  // Sempre un solo intervallo effettivo su curva chiusa
+   double dTrimS, dTrimE, dDummy ;
+   if ( inOk.GetCount() == 1)
+      inOk.GetFirst( dTrimS, dTrimE) ;
+   else if ( inOk.GetCount() == 2) {
+      inOk.GetFirst( dDummy, dTrimE) ;
+      inOk.GetNext( dTrimS, dDummy) ;
+   }
+   else
+      return false ;
+   if ( ! pOutLoop->TrimStartEndAtParam( dTrimS, dTrimE))
+      return false ;
+  // assegno la nuova curva
+   Clear() ;
+   return AddCurve( Release( pOutLoop)) ;
+}
diff --git a/CurveComposite.h b/CurveComposite.h
index 38bccf7..f091a80 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -150,6 +150,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool ArcsToBezierCurves( void) override ;
       bool ArcsBezierCurvesToArcsPerpExtr( double dLinTol, double dAngTolDeg) override ;
       bool MergeCurves( double dLinTol, double dAngTolDeg) override ;
+      bool RemoveUndercutOnY( double dLinTol, double dAngTolDeg) override ;
 
    public :                      // IGeoObjRW
       virtual int GetNgeId( void) const ;
diff --git a/CurveCompositeOffset.cpp b/CurveCompositeOffset.cpp
index 88b553e..5037fe6 100644
--- a/CurveCompositeOffset.cpp
+++ b/CurveCompositeOffset.cpp
@@ -68,7 +68,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType)
    if ( IsNull( pCrv1))
       return false ;
    // se la curva è una linea verticale in Z, passo alla successiva
-   if ( IsVerticalLine( Get( pCrv1), &dLenVertFirst)) {
+   if ( IsVerticalLine( pCrv1, &dLenVertFirst)) {
       if ( bNoVertLine)
          return false ;
       pCrv1.Set( ccCopy.RemoveFirstOrLastCurve( false)) ;
@@ -78,14 +78,14 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType)
       return false ;
    if ( ! pCrv1->SimpleOffset( dDist, nType))
       return false ;
-   ICurve* pCrvPrev = Get( pCrv1) ;
+   ICurve* pCrvPrev = pCrv1 ;
    if ( ! ccOffs.AddSimpleCurve( Release( pCrv1)))
       return false ;
    // curve successive
    PtrOwner<ICurve> pCrv2( ccCopy.RemoveFirstOrLastCurve( false)) ;
    while ( ! IsNull( pCrv2)) {
      // se la curva è una linea verticale in Z, passo alla successiva
-      if ( IsVerticalLine( Get( pCrv2), &dLenVertLast)) {
+      if ( IsVerticalLine( pCrv2, &dLenVertLast)) {
          if ( bNoVertLine)
             return false ;
          pCrv2.Set( ccCopy.RemoveFirstOrLastCurve( false)) ;
@@ -96,9 +96,9 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType)
          return false ;
      // verifico relazione con la curva precedente e aggiungo eventuali curve intermedie
       CurveComposite ccTemp ;
-      if ( VerifyAndAdjustSamePoint( pCrvPrev, Get( pCrv2), ccTemp)  ||
-           VerifyAndAdjustInternalAngle( pCrvPrev, Get( pCrv2), ccTemp)  ||
-           VerifyAndAdjustExternalAngle( pCrvPrev, Get( pCrv2), dDist, nType, ccTemp)) {
+      if ( VerifyAndAdjustSamePoint( pCrvPrev, pCrv2, ccTemp)  ||
+           VerifyAndAdjustInternalAngle( pCrvPrev, pCrv2, ccTemp)  ||
+           VerifyAndAdjustExternalAngle( pCrvPrev, pCrv2, dDist, nType, ccTemp)) {
          if ( ccTemp.GetCurveCount() > 0  &&  ! ccOffs.AddCurveByRelocate( ccTemp))
             return false ;
       }
@@ -106,7 +106,7 @@ CurveComposite::SimpleOffsetXY( double dDist, int nType)
       else
          return false ;
      // aggiorno curva precedente
-      pCrvPrev = Get( pCrv2) ;
+      pCrvPrev = pCrv2 ;
      // inserisco nell'offset
       if ( ! ccOffs.AddSimpleCurve( Release( pCrv2)))
          return false ;
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 1d3afc6..349a198 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/FilletChamfer.cpp b/FilletChamfer.cpp
index 4412d65..92caa01 100644
--- a/FilletChamfer.cpp
+++ b/FilletChamfer.cpp
@@ -73,7 +73,7 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
    Point3d ptInt1, ptInt2 ;
    Point3d ptNear1I = ptNear1 ;
    ptNear1I.ToLoc( frIntr) ;
-   IntersCurveCurve intCC( *Get( pCopy1), *Get( pCopy2)) ;
+   IntersCurveCurve intCC( *pCopy1, *pCopy2) ;
    if ( ! intCC.GetIntersPointNearTo( 0, ptNear1I, ptInt1)  ||
         ! intCC.GetIntersPointNearTo( 1, ptNear1I, ptInt2))
       return nullptr ;
@@ -168,7 +168,7 @@ CreateChamfer( const ICurve& cCrv1, const Point3d& ptNear1,
    Point3d ptInt1, ptInt2 ;
    Point3d ptNear1I = ptNear1 ;
    ptNear1I.ToLoc( frIntr) ;
-   IntersCurveCurve intCC( *Get( pCopy1), *Get( pCopy2)) ;
+   IntersCurveCurve intCC( *pCopy1, *pCopy2) ;
    if ( ! intCC.GetIntersPointNearTo( 0, ptNear1I, ptInt1)  ||
         ! intCC.GetIntersPointNearTo( 1, ptNear1I, ptInt2))
       return nullptr ;
diff --git a/FontOs.cpp b/FontOs.cpp
index d7a90df..3db4e1b 100644
--- a/FontOs.cpp
+++ b/FontOs.cpp
@@ -622,7 +622,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
    if ( IsNull( pBuffer))
       return false ;
   // recupero l'outline
-   DWORD dErr = GetGlyphOutlineW( m_hDC, nChar, GGO_NATIVE, &gm, dwSize, ::Get( pBuffer), &mat) ;
+   DWORD dErr = GetGlyphOutlineW( m_hDC, nChar, GGO_NATIVE, &gm, dwSize, pBuffer, &mat) ;
    if ( dErr == GDI_ERROR)
       return false ;
 
@@ -631,7 +631,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
 
   // mentre esistono nuovi contorni
    LPTTPOLYGONHEADER pHeader = (LPTTPOLYGONHEADER) ::Get( pBuffer) ;
-   while ( (LPSTR) pHeader < ( ::Get( pBuffer) + ptrdiff_t( dwSize))) {
+   while ( (LPSTR) pHeader < ( pBuffer + ptrdiff_t( dwSize))) {
 
      // leggo un nuovo contorno
       if ( pHeader->dwType == TT_POLYGON_TYPE) {
@@ -662,7 +662,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
                                0) ;
                   if ( ! AreSamePointApprox( ptLast, ptP)) {
                     // aggiungo la retta alla curva composita
-                     if ( ! AddLineToCompo( ::Get( pCCompo), ptLast, ptP))
+                     if ( ! AddLineToCompo( pCCompo, ptLast, ptP))
                         return false ;
                     // salvo punto come ultimo
                      ptLast = ptP ;
@@ -689,7 +689,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
                                DoubleFromFixed( pfEnd.y),
                                0) ;
                  // aggiungo la curva di Bezier quadratica alla curva composita
-                  if ( ! AddCBezierQuadToCompo( ::Get( pCCompo), ptLast, ptM, ptE))
+                  if ( ! AddCBezierQuadToCompo( pCCompo, ptLast, ptM, ptE))
                      return false ;
                  // salvo punto finale come ultimo
                   ptLast = ptE ;
@@ -705,7 +705,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
         // si aggiunge, se necessario, una linea retta per chiudere la curva
          if ( ! AreSamePointApprox( ptFirst, ptLast)) {
            // aggiungo la retta alla curva composita
-            if ( ! AddLineToCompo( ::Get( pCCompo), ptLast, ptFirst))
+            if ( ! AddLineToCompo( pCCompo, ptLast, ptFirst))
                return false ;
            // salvo ultimo punto
             ptLast = ptFirst ;
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index d33d194..fa3ad9f 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -1858,13 +1858,13 @@ GdbExecutor::CurveCompoFromCurveApproximation( const STRVECTOR& vsParams)
       return false ;
    if ( nType == 1) {       // con linee
       PolyLine PL ;
-      if ( ! CrvLoc.Get()->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL)  ||
+      if ( ! CrvLoc->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL)  ||
            ! pCC->FromPolyLine( PL))
          return false ;
    }
    else {                   // con bi-archi
       PolyArc PA ;
-      if ( ! CrvLoc.Get()->ApproxWithArcsEx( dLinTol, ANG_TOL_STD_DEG, LIN_FEA_LEN_STD, PA)  ||
+      if ( ! CrvLoc->ApproxWithArcsEx( dLinTol, ANG_TOL_STD_DEG, LIN_FEA_LEN_STD, PA)  ||
            ! pCC->FromPolyArc( PA))
          return false ;
    }
@@ -2343,7 +2343,7 @@ GdbExecutor::SurfTriMeshByFlatContour( const STRVECTOR& vsParams)
    if ( vsParams.size() == 4)
       FromString( vsParams[3], dLinTol) ;
   // calcolo la superficie
-   ISurfTriMesh* pSTM = GetSurfTriMeshByFlatContour( CrvLoc.Get(), dLinTol) ;
+   ISurfTriMesh* pSTM = GetSurfTriMeshByFlatContour( CrvLoc, dLinTol) ;
    if ( pSTM == nullptr)
       return false ;
   // inserisco la superficie trimesh nel DB
@@ -2375,7 +2375,7 @@ GdbExecutor::SurfTriMeshByExtrusion( const STRVECTOR& vsParams)
    if ( vsParams.size() == 5)
       FromString( vsParams[4], dLinTol) ;
   // calcolo la superficie
-   ISurfTriMesh* pSTM = GetSurfTriMeshByExtrusion( CrvLoc.Get(), vtExtr, false, dLinTol) ;
+   ISurfTriMesh* pSTM = GetSurfTriMeshByExtrusion( CrvLoc, vtExtr, false, dLinTol) ;
    if ( pSTM == nullptr)
       return false ;
   // inserisco la superficie trimesh nel DB
@@ -2408,7 +2408,7 @@ GdbExecutor::SurfTriMeshByTwoPaths( const STRVECTOR& vsParams)
    if ( vsParams.size() == 5)
       FromString( vsParams[4], dLinTol) ;
   // calcolo la superficie
-   ISurfTriMesh* pSTM = GetSurfTriMeshRuled( CrvLoc1.Get(), CrvLoc2.Get(), dLinTol) ;
+   ISurfTriMesh* pSTM = GetSurfTriMeshRuled( CrvLoc1, CrvLoc2, dLinTol) ;
    if ( pSTM == nullptr)
       return false ;
   // inserisco la superficie trimesh nel DB
@@ -2466,7 +2466,7 @@ GdbExecutor::SurfTriMeshByScrewing( bool bMove, const STRVECTOR& vsParams)
    if ( ! FromString( vsParams[5], dAngRotDeg))
       return false ;
   // calcolo la superficie
-   ISurfTriMesh* pSTM = GetSurfTriMeshByScrewing( CrvLoc.Get(), ptAx, vtAx, dAngRotDeg, dMove, dLinTol) ;
+   ISurfTriMesh* pSTM = GetSurfTriMeshByScrewing( CrvLoc, ptAx, vtAx, dAngRotDeg, dMove, dLinTol) ;
    if ( pSTM == nullptr)
       return false ;
   // inserisco la superficie trimesh nel DB
@@ -3441,13 +3441,13 @@ GdbExecutor::GetPointParam( const string& sParam, const Frame3d& frPnt, Point3d&
                   if ( ! m_pGDB->GetGlobFrame( nIdEnt2, frEnt2))
                      return false ;
                   // se il riferimento è diverso da quello della prima entità, devo trasformarla
-                  PtrOwner<ICurve> crvTrans( nullptr) ;
+                  PtrOwner<ICurve> pcrvTrans( nullptr) ;
                   if ( ! AreSameFrame( frEnt, frEnt2)) {
-                     crvTrans.Set( pCrv2->Clone()) ;
-                     if ( IsNull( crvTrans))
+                     pcrvTrans.Set( pCrv2->Clone()) ;
+                     if ( IsNull( pcrvTrans))
                         return false ;
-                     crvTrans->LocToLoc( frEnt2, frEnt) ;
-                     pCrv2 = ::Get( crvTrans) ;
+                     pcrvTrans->LocToLoc( frEnt2, frEnt) ;
+                     pCrv2 = pcrvTrans ;
                   }
                  // eventuale terzo parametro : punto di riferimento
                   Point3d ptRef ;
@@ -5212,13 +5212,13 @@ GdbExecutor::CurveCopyBySplitClass( const STRVECTOR& vsParams)
    if ( ! m_pGDB->GetGlobFrame( nIdCloCrv, frCloCrv))
       return false ;
   // se i riferimenti sono diversi, porto la seconda curva nel riferimento della prima
-   PtrOwner<ICurve> crvTrans ;
+   PtrOwner<ICurve> pcrvTrans ;
    if ( ! AreSameFrame( frCrv, frCloCrv)) {
-      crvTrans.Set( pCloCrv->Clone()) ;
-      if ( IsNull( crvTrans))
+      pcrvTrans.Set( pCloCrv->Clone()) ;
+      if ( IsNull( pcrvTrans))
          return false ;
-      crvTrans->LocToLoc( frCloCrv, frCrv) ;
-      pCloCrv = ::Get( crvTrans) ;
+      pcrvTrans->LocToLoc( frCloCrv, frCrv) ;
+      pCloCrv = pcrvTrans ;
    }
   // calcolo le intersezioni tra le due curve
    IntersCurveCurve intCC( *pCrv, *pCloCrv, true) ;
@@ -5472,13 +5472,13 @@ GdbExecutor::ExecuteOutTextIcci( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! m_pGDB->GetGlobFrame( nIdEnt2, frEnt2))
       return false ;
   // se i riferimenti sono diversi, porto la seconda entità nel riferimento della prima
-   PtrOwner<ICurve> crvTrans ;
+   PtrOwner<ICurve> pcrvTrans ;
    if ( ! AreSameFrame( frEnt1, frEnt2)) {
-      crvTrans.Set( pCrv2->Clone()) ;
-      if ( IsNull( crvTrans))
+      pcrvTrans.Set( pCrv2->Clone()) ;
+      if ( IsNull( pcrvTrans))
          return false ;
-      crvTrans->LocToLoc( frEnt2, frEnt1) ;
-      pCrv2 = ::Get( crvTrans) ;
+      pcrvTrans->LocToLoc( frEnt2, frEnt1) ;
+      pCrv2 = pcrvTrans ;
    }
   // calcolo le intersezioni tra le due curve
    IntersCurveCurve intCC( *pCrv1, *pCrv2, true) ;
diff --git a/GeomDB.cpp b/GeomDB.cpp
index dd2f640..265af89 100644
--- a/GeomDB.cpp
+++ b/GeomDB.cpp
@@ -1063,7 +1063,7 @@ GeomDB::Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGl
    }
 
   // inserisco nel DB (non rilascio il puntatore)
-   if ( ! InsertInGeomDB( ::Get( pGdODest), nRefId, nSonBeforeAfter))
+   if ( ! InsertInGeomDB( pGdODest, nRefId, nSonBeforeAfter))
       return GDB_ID_NULL ;
 
   // rilascio il puntatore
diff --git a/IntersCurveCurve.cpp b/IntersCurveCurve.cpp
index 51751a5..089a18a 100644
--- a/IntersCurveCurve.cpp
+++ b/IntersCurveCurve.cpp
@@ -57,9 +57,9 @@ IntersCurveCurve::IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB,
          pTmpCrv[i].Set( CreateBasicCurveComposite()) ;
          if ( IsNull( pTmpCrv[i]))
             return ;
-         if ( ! GetBasicCurveComposite( Get( pTmpCrv[i]))->FromPolyLine( PL))
+         if ( ! GetBasicCurveComposite( pTmpCrv[i])->FromPolyLine( PL))
             return ;
-         pCalcCrv[i] = Get( pTmpCrv[i]) ;
+         pCalcCrv[i] = pTmpCrv[i] ;
       }
       else
          pCalcCrv[i] = m_pCurve[i] ;
diff --git a/IntersLineArc.cpp b/IntersLineArc.cpp
index 6d3b4aa..675953c 100644
--- a/IntersLineArc.cpp
+++ b/IntersLineArc.cpp
@@ -70,8 +70,8 @@ IntersLineArc::IntersLineArc( const CurveLine& Line, const CurveArc& Arc)
       return ;
 
   // se distanza uguale al raggio -> una intersezione tangente, è la proiezione
-  // (verifico che la distanza tra la proiezione e i punti di secanza sia minore di epsilon)
-   if ( dSqDelta < EPS_SMALL * EPS_SMALL) {
+  // (corrisponde a una differenza max di EPS_SMALL tra i valori)
+   if ( dSqDelta <  2 * m_Arc.GetRadius() * EPS_SMALL) {
      // determinazione geometrica dell'intersezione tra le due curve
       int nPosL, nPosA ;
       if ( ! CalcIntersGeomData( 0, ptPrjCen, nPosL, nPosA))
diff --git a/OffsetCurve.cpp b/OffsetCurve.cpp
index 32650a9..53f618c 100644
--- a/OffsetCurve.cpp
+++ b/OffsetCurve.cpp
@@ -146,7 +146,7 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
       return false ;
    pCrv1->SetTempProp( nInd1) ;
    if ( ! pCrv1->SimpleOffset( dDist, ICurve::OFF_FILLET)  &&
-        GetBasicCurveArc( Get( pCrv1))->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
+        GetBasicCurveArc( pCrv1)->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
       pCrv1->SetTempProp( - nInd1) ;
    // curve successive
    PtrOwner<ICurve> pCrv2( ccCopy2.RemoveFirstOrLastCurve( false)) ;
@@ -154,11 +154,11 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
      // eseguo semplice offset
       pCrv2->SetTempProp( nInd1 + 1) ;
       if ( ! pCrv2->SimpleOffset( dDist, ICurve::OFF_FILLET)  &&
-           GetBasicCurveArc( Get( pCrv2))->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
+           GetBasicCurveArc( pCrv2)->MyExtendedOffset( dDist, true, ICurve::OFF_FILLET))
          pCrv2->SetTempProp( - (nInd1 + 1)) ;
      // verifico relazione con la curva precedente e aggiungo eventuali curve intermedie
       CurveComposite ccTemp ;
-      bool bOk = VerifyAndAdjustExternalAngle( Get( pCrv1), Get( pCrv2), vAngs[nInd1], dDist, ICurve::OFF_FILLET, ccTemp) ;
+      bool bOk = VerifyAndAdjustExternalAngle( pCrv1, pCrv2, vAngs[nInd1], dDist, ICurve::OFF_FILLET, ccTemp) ;
      // metto in lista curva precedente
       m_CrvLst.push_back( Release( pCrv1)) ;
      // se aggiunto qualcosa, lo metto in lista
@@ -407,9 +407,9 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
          PtrOwner<ICurve> pCrv( pCrvCo->RemoveFirstOrLastCurve( false)) ;
          while ( ! IsNull( pCrv)) {
            // se fillet lo trasformo in smusso o estensione
-            if ( IsFillet( Get( pCrv), dDist)) {
+            if ( IsFillet( pCrv, dDist)) {
                CurveComposite ccTemp ;
-               bool bOk = ModifyFillet( Get( pCrv), dDist, nType, ccTemp) ;
+               bool bOk = ModifyFillet( pCrv, dDist, nType, ccTemp) ;
               // metto in lista le curve risultanti
                if ( ccTemp.GetCurveCount() > 0) {
                   PtrOwner<ICurve> pCrv2( ccTemp.RemoveFirstOrLastCurve( false)) ;
diff --git a/OffsetCurveOnX.cpp b/OffsetCurveOnX.cpp
index 2bd3993..02b0235 100644
--- a/OffsetCurveOnX.cpp
+++ b/OffsetCurveOnX.cpp
@@ -89,6 +89,15 @@ OffsetCurveOnX::Make( const ICurve* pCrv, double dDist)
    if ( ! SplitLeftRightArcs( ccCopy))
       return false ;
 
+  // se offset nullo, copio la curva nel risultato ed esco
+   if ( abs( dDist) < EPS_SMALL) {
+      PtrOwner<CurveComposite> pCopy( CreateBasicCurveComposite()) ;
+      if ( IsNull( pCopy)  ||  ! pCopy->RelocateFrom( ccCopy))
+         return false ;
+      m_CrvLst.push_back( Release( pCopy)) ;
+      return true ;
+   }
+
   // verifico se curva chiusa
    bool bClosed = ccCopy.IsClosed() ;
 
@@ -104,13 +113,13 @@ OffsetCurveOnX::Make( const ICurve* pCrv, double dDist)
       return false ;
    // eseguo semplice offset orizzontale
    pCrv1->SetTempProp( nInd1) ;
-   SimpleOffsetOnX( Get( pCrv1), dDist) ;
+   SimpleOffsetOnX( pCrv1, dDist) ;
    // curve successive
    PtrOwner<ICurve> pCrv2( ccCopy2.RemoveFirstOrLastCurve( false)) ;
    while ( ! IsNull( pCrv2)) {
      // eseguo semplice offset
       pCrv2->SetTempProp( nInd1 + 1) ;
-      SimpleOffsetOnX( Get( pCrv2), dDist) ;
+      SimpleOffsetOnX( pCrv2, dDist) ;
      // metto in lista curva precedente
       m_CrvLst.push_back( Release( pCrv1)) ;
      // aggiorno curva precedente
@@ -362,7 +371,7 @@ SplitLeftRightArcs( CurveComposite& cCompo)
          }
         // verifico la seconda
          else if ( abs( dAng2) > EPS_ANG_SMALL  &&  abs( dAng2) < abs( pArc->GetAngCenter()) - EPS_ANG_SMALL) {
-            cCompo.AddJoint(  i + dAng2 / pArc->GetAngCenter()) ;
+            cCompo.AddJoint( i + dAng2 / pArc->GetAngCenter()) ;
          }
       }  
      // passo alla successiva
@@ -387,9 +396,6 @@ SimpleOffsetOnX( ICurve* pCrv, double dDist)
    return true ;
 }
 
-
-
-
 //----------------------------------------------------------------------------
 bool
 VerifyAndAdjustSamePoint( ICurve* pCrv1, ICurve* pCrv2)
diff --git a/SelfIntersCurve.cpp b/SelfIntersCurve.cpp
index 715ed76..64fb839 100644
--- a/SelfIntersCurve.cpp
+++ b/SelfIntersCurve.cpp
@@ -54,9 +54,9 @@ SelfIntersCurve::SelfIntersCurve( const ICurve& Curve)
       pTmpCrv.Set( CreateBasicCurveComposite()) ;
       if ( IsNull( pTmpCrv))
          return ;
-      if ( ! GetBasicCurveComposite( Get( pTmpCrv))->FromPolyLine( PL))
+      if ( ! GetBasicCurveComposite( pTmpCrv)->FromPolyLine( PL))
          return ;
-      pCalcCrv = Get( pTmpCrv) ;
+      pCalcCrv = pTmpCrv ;
      // salvo la parametrizzazione della approssimazione temporanea
       vTmpPar.reserve( PL.GetPointNbr()) ;
       double dPar ;
diff --git a/Simple CDSurfFrMove.cpp b/Simple CDSurfFrMove.cpp
index 02feff7..2ffa45d 100644
--- a/Simple CDSurfFrMove.cpp	
+++ b/Simple CDSurfFrMove.cpp	
@@ -114,7 +114,7 @@ MySimpleCDSurfFrMove::Translate( const Vector3d& vtDir, double& dLen)
          if ( IsNull( pCopyCrv))
             return REGC_NULL ;
          pCopyCrv->LocToLoc( m_pRegF->m_frF, m_pRegM->m_frF) ;
-         pCrv2Loc = Get( pCopyCrv) ;
+         pCrv2Loc = pCopyCrv ;
       }
 
      // ciclo sui chunk della prima superficie
@@ -213,7 +213,7 @@ MySimpleCDSurfFrMove::Rotate( const Point3d& ptCen, double& dAng)
          if ( IsNull( pCopyCrv))
             return REGC_NULL ;
          pCopyCrv->LocToLoc( m_pRegF->m_frF, m_pRegM->m_frF) ;
-         pCrv2Loc = Get( pCopyCrv) ;
+         pCrv2Loc = pCopyCrv ;
       }
 
      // ciclo sui chunk della prima superficie
diff --git a/SurfFlatRegion.cpp b/SurfFlatRegion.cpp
index 13417b8..c411b3a 100644
--- a/SurfFlatRegion.cpp
+++ b/SurfFlatRegion.cpp
@@ -181,7 +181,7 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv)
    if ( ! bOk)
       return false ;
   // assegno la curva come loop esterno
-   if ( MyAddExtLoop( Get( pMyCrv)))
+   if ( MyAddExtLoop( pMyCrv))
       Release( pMyCrv) ;
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
@@ -292,7 +292,7 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
          return false ;
    }
   // aggiungo la curva all'elenco dei loop
-   if ( MyAddIntLoop( Get( pMyCrv)))
+   if ( MyAddIntLoop( pMyCrv))
       Release( pMyCrv) ;
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
@@ -1002,7 +1002,7 @@ SurfFlatRegion::GetAuxSurf( void) const
      // porto la trimesh in globale al riferimento intrinseco
       pChSTM->ToGlob( m_frF) ;
      // inserisco questa trimesh in quella complessiva
-      pSTM->DoSewing( *Get( pChSTM)) ; 
+      pSTM->DoSewing( *pChSTM) ; 
    }
    // la salvo
    m_pSTM = Release( pSTM) ;
@@ -1187,7 +1187,7 @@ SurfFlatRegion::GetCurveClassification( const ICurve& Crv, CRVCVECTOR& ccClass)
       if ( IsNull( pCopyCrv))
          return false ;
       pCopyCrv->ToLoc( m_frF) ;
-      pCrvLoc = Get( pCopyCrv) ;
+      pCrvLoc = pCopyCrv ;
    }
   // esecuzione classificazione nel riferimento intrinseco
    return MyGetCurveClassification( *pCrvLoc, ccClass) ;
@@ -1223,7 +1223,7 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
       if ( IsNull( pCopyCrv))
          return REGC_NULL ;
       pCopyCrv->LocToLoc( Reg2.m_frF, m_frF) ;
-      pCrv2Loc = Get( pCopyCrv) ;
+      pCrv2Loc = pCopyCrv ;
    }
 
   // se i box delle due curve sono esterni, i chunk sono esterni
diff --git a/SurfFlatRegionBooleans.cpp b/SurfFlatRegionBooleans.cpp
index 82b3571..404657f 100644
--- a/SurfFlatRegionBooleans.cpp
+++ b/SurfFlatRegionBooleans.cpp
@@ -59,7 +59,7 @@ SurfFlatRegion::Add( const ISurfFlatRegion& Other)
      // assegno il nuovo riferimento
       pCopyOth->m_frF = m_frF ;
      // aggiorno puntatore della copia in lavoro
-      pOther = Get( pCopyOth) ;
+      pOther = pCopyOth ;
    }
 
   // vettore con curve utili da entrambe le regioni
@@ -138,7 +138,7 @@ SurfFlatRegion::Subtract( const ISurfFlatRegion& Other)
      // assegno il nuovo riferimento
       pCopyOth->m_frF = m_frF ;
      // aggiorno puntatore della copia in lavoro
-      pOther = Get( pCopyOth) ;
+      pOther = pCopyOth ;
    }
 
   // vettore con curve utili da entrambe le regioni
@@ -221,7 +221,7 @@ SurfFlatRegion::Intersect( const ISurfFlatRegion& Other)
      // assegno il nuovo riferimento
       pCopyOth->m_frF = m_frF ;
      // aggiorno puntatore della copia in lavoro
-      pOther = Get( pCopyOth) ;
+      pOther = pCopyOth ;
    }
 
   // vettore con curve utili da entrambe le regioni
diff --git a/SurfFlatRegionOffset.cpp b/SurfFlatRegionOffset.cpp
index 4204192..c2777b4 100644
--- a/SurfFlatRegionOffset.cpp
+++ b/SurfFlatRegionOffset.cpp
@@ -69,12 +69,12 @@ SurfFlatRegion::Offset( double dDist, int nType)
                   return false ;
               // se era loop esterno, lo aggiungo alla nuova regione
                if ( j == 0) {
-                  if ( ! pSfrChk->Add( *Get( pSfr2)))
+                  if ( ! pSfrChk->Add( *pSfr2))
                      return false ;
                }
               // altrimenti loop interno, lo sottraggo alla nuova regione
                else {
-                  if ( ! pSfrChk->Subtract( *Get( pSfr2)))
+                  if ( ! pSfrChk->Subtract( *pSfr2))
                      return false ;
                }
             }
@@ -95,7 +95,7 @@ SurfFlatRegion::Offset( double dDist, int nType)
          }
         // altrimenti la aggiungo alla nuova regione
          else {
-            if ( ! pSfr->Add( *Get( pSfrChk)))
+            if ( ! pSfr->Add( *pSfrChk))
                return false ;
          }
       }