diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index 23431f6..ae97cb7 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -1519,10 +1519,27 @@ SurfBezier::GetAuxSurf( void) const
    if ( m_pSTM != nullptr)
       return m_pSTM ;
   // eseguo calcolo
-   m_pSTM = GetApproxSurf( 50 * EPS_SMALL, 100 * EPS_SMALL) ;
+   m_pSTM = GetApproxSurf( 1000 * EPS_SMALL, 100 * EPS_SMALL) ;
    return m_pSTM ;
 }
 
+//----------------------------------------------------------------------------
+const SurfTriMesh*
+SurfBezier::GetAuxSurfRefined( void) const
+{
+  // la superficie deve essere validata
+   if ( m_nStatus != OK) {
+      ResetAuxSurf() ;
+      return nullptr ;
+   }
+  // se già calcolata, la restituisco
+   if ( m_pSTMRefined != nullptr)
+      return m_pSTMRefined ;
+  // eseguo calcolo
+   m_pSTMRefined = GetApproxSurf( 50 * EPS_SMALL, 100 * EPS_SMALL) ;
+   return m_pSTMRefined ;
+}
+
 //----------------------------------------------------------------------------
 SurfTriMesh*
 SurfBezier::GetApproxSurf( double dTol, double dSideMin) const
@@ -1531,10 +1548,14 @@ SurfBezier::GetApproxSurf( double dTol, double dSideMin) const
    if ( m_nStatus != OK)
       return nullptr ;
 
-  // se c'è ausiliaria e richiesta con gli stessi parametri, ne restituisco una copia
-   if ( m_pSTM != nullptr  &&
-        abs( dTol - 50 * EPS_SMALL) < EPS_SMALL  &&  abs( dSideMin - 100 * EPS_SMALL) < EPS_SMALL)
+  // se c'è ausiliaria di visualizzazione con gli stessi parametri, ne restituisco una copia
+   if ( m_pSTM!= nullptr  &&
+        abs( dTol - 1000 * EPS_SMALL) < EPS_SMALL  &&  abs( dSideMin - 100 * EPS_SMALL) < EPS_SMALL)
       return m_pSTM->Clone() ;
+  // se c'è ausiliaria e richiesta con gli stessi parametri, ne restituisco una copia
+   if ( m_pSTMRefined != nullptr  &&
+        abs( dTol - 50 * EPS_SMALL) < EPS_SMALL  &&  abs( dSideMin - 100 * EPS_SMALL) < EPS_SMALL)
+      return m_pSTMRefined->Clone() ;
   
   // costruttore della superficie
    POLYLINEMATRIX vvPL ;
@@ -1895,6 +1916,9 @@ SurfBezier::ResetAuxSurf( void) const
    if ( m_pSTM != nullptr)
       delete( m_pSTM) ;
    m_pSTM = nullptr ;
+   if ( m_pSTMRefined != nullptr)
+      delete( m_pSTMRefined) ;
+   m_pSTMRefined = nullptr ;
 
    m_mCCEdge.clear() ;
    m_vCCLoop.clear() ;
@@ -2422,7 +2446,7 @@ SurfBezier::Cut( const Plane3d& plPlane, bool bSaveOnEq)
    PNTVECTOR vPnt ;
    BIPNTVECTOR vBPnt ;
    TRIA3DVECTOR vTria ;
-   IntersPlaneSurfTm( plPlane, *GetAuxSurf(), vPnt, vBPnt, vTria) ;
+   IntersPlaneSurfTm( plPlane, *GetAuxSurfRefined(), vPnt, vBPnt, vTria) ;
 
    // concateno le curve 3d
    ChainCurves chainC ;
@@ -2595,7 +2619,7 @@ SurfBezier::UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, in
    if ( bThroughEdge != nullptr)
       *bThroughEdge = false ;
    // dato un punto sulla trimesh ausiliaria, ne ricavo le coordinate parametriche
-   const ISurfTriMesh* pSurfTm = GetAuxSurf() ;
+   const ISurfTriMesh* pSurfTm = GetAuxSurfRefined() ;
    int nTriaIndex = nT ;
    if ( nT == -1) {
       DistPointSurfTm distPtStm0( ptI, *pSurfTm) ;
@@ -2891,7 +2915,7 @@ SurfBezier::UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d
    // trovato un primo candidato ptParam, ne calcolo l'immagine sulla superficie ( ptBez) e ne calcolo la distanza con il punto pt3D
    // ripeto cercando di avvicinarmi il più possibile
    // per trovare il primo punto trovo il triangolo della trimesh ausiliaria più vicino e il punto più vicino
-   DistPointSurfTm dptSurfTm( pt3D, *GetAuxSurf()) ;
+   DistPointSurfTm dptSurfTm( pt3D, *GetAuxSurfRefined()) ;
    Point3d ptI ; dptSurfTm.GetMinDistPoint( ptI) ;
    if ( ! UnprojectPointFromStm( -1, ptI, ptParam, 5, ptIPrev, bThroughEdge))
       return false ;
@@ -3056,7 +3080,7 @@ SurfBezier::GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge) con
    // se nEdge non è definito ( == -1) allora restituisco tutti gli edge in ordine
    // se bOpenOrAll è true allora restituisco solo gli edge aperti e che non sono di polo
    if ( m_pSTM == nullptr)
-      GetAuxSurf() ;
+      GetAuxSurfRefined() ;
    
    // se la superficie non è trimmata mi basta recuperare gli edge della superficie
    if ( ! m_bTrimmed) {
@@ -3402,7 +3426,7 @@ ICurveComposite*
 SurfBezier::GetSingleEdge3D( bool bLineOrBezier, int nEdge) const
 {
    if ( m_mCCEdge.empty()  &&  bLineOrBezier)
-      GetAuxSurf() ;
+      GetAuxSurfRefined() ;
    // questa funzione dà per scontato che la superficie NON sia trimmata
    if ( nEdge < 0  || nEdge > 3  ||  m_bTrimmed)
       return nullptr ;
diff --git a/SurfBezier.h b/SurfBezier.h
index 53b0e86..b7d4b3c 100644
--- a/SurfBezier.h
+++ b/SurfBezier.h
@@ -117,6 +117,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const override ;
       bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
+      const SurfTriMesh* GetAuxSurfRefined( void) const override ;
       SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const override ;
       // funzione per ottenere la suddivisione dello spazio parametrico nelle celle utilizzate per la triangolazione.
       bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const override ;
@@ -212,7 +213,8 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
 
    private :
       ObjGraphicsMgr  m_OGrMgr ;        // gestore grafica dell'oggetto
-      mutable SurfTriMesh* m_pSTM ;     // superficie trimesh ausiliaria
+      mutable SurfTriMesh* m_pSTM ;     // superficie trimesh ausiliaria per la visualizzazione
+      mutable SurfTriMesh* m_pSTMRefined ; // superficie trimesh ausiliaria raffinata per i calcoli
       Status          m_nStatus ;       // stato
       int             m_nDegU ;         // grado in U
       int             m_nDegV ;         // grado in V