diff --git a/ChainCurves.cpp b/ChainCurves.cpp
index 8e902da..cd024cb 100644
--- a/ChainCurves.cpp
+++ b/ChainCurves.cpp
@@ -54,7 +54,7 @@ ChainCurves::AddCurve( int nId, const Point3d& ptStart, const Vector3d& vtStart,
 
 //----------------------------------------------------------------------------
 bool
-ChainCurves::GetChainFromNear( const Point3d& ptStart, INTVECTOR& vIds)
+ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECTOR& vIds)
 {
   // pulisco il risultato
    vIds.clear() ;
@@ -75,15 +75,21 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, INTVECTOR& vIds)
 
   // concateno dopo la fine dell'entità di partenza
    INTVECTOR vIdsAfter ;
-   if ( ! GetChainFromPoint( m_vCrvData[nId].ptEnd, m_vCrvData[nId].vtEnd, false, vIdsAfter))
+   bool bClosed ;
+   if ( ! GetChainFromPoint( m_vCrvData[nId].ptEnd, m_vCrvData[nId].vtEnd,
+                             m_vCrvData[nId].ptStart, bHaltOnFork, vIdsAfter, bClosed))
       return false ;
 
-  // concateno prima dell'inizio dell'entità di partenza
+  // se non ho già chiuso l'anello, concateno prima dell'inizio dell'entità di partenza
    INTVECTOR vIdsBefore ;
-   if ( ! GetReverseChainFromPoint( m_vCrvData[nId].ptStart, m_vCrvData[nId].vtStart, false, vIdsBefore))
-      return false ;
-  // inverto l'ordine
-   reverse( vIdsBefore.begin(), vIdsBefore.end()) ;
+   if ( ! bClosed) {
+      bool bRevClosed ;
+      if ( ! GetReverseChainFromPoint( m_vCrvData[nId].ptStart, m_vCrvData[nId].vtStart,
+                                       m_vCrvData[nId].ptEnd, bHaltOnFork, vIdsBefore, bRevClosed))
+         return false ;
+     // inverto l'ordine
+      reverse( vIdsBefore.begin(), vIdsBefore.end()) ;
+   }
 
   // inserisco i risultati nel vettore complessivo
    vIds.reserve( vIdsBefore.size() + 1 + vIdsAfter.size()) ;
@@ -96,11 +102,13 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, INTVECTOR& vIds)
 
 //----------------------------------------------------------------------------
 bool
-ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart, bool bStopOnFork,
-                                INTVECTOR& vIds)
+ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
+                                const Point3d& ptStop, bool bHaltOnFork,
+                                INTVECTOR& vIds, bool& bStopped)
 {
   // pulisco il risultato
    vIds.clear() ;
+   bStopped = false ;
    m_bIsFork = false ;
    m_vFork.clear() ;
 
@@ -110,7 +118,7 @@ ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
    int nNext ;
    INTVECTOR vNext ;
    while ( m_PointGrid.Find( ptCurr, m_dToler, vNext)  &&
-           ChooseNext( vtCurr, vNext, bStopOnFork, nNext)) {
+           ChooseNext( vtCurr, vNext, bHaltOnFork, nNext)) {
      // recupero indice e verso
       int nId = abs( nNext) - 1 ;
       bool bEquiv = ( nNext > 0) ;
@@ -121,6 +129,11 @@ ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
      // determino il prossimo inizio
       ptCurr = bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart ;
       vtCurr = bEquiv ? m_vCrvData[nId].vtEnd : - m_vCrvData[nId].vtStart ;
+     // verifico se sono arrivato al punto di chiusura
+      if ( AreSamePointEpsilon( ptCurr, ptStop, m_dToler)) {
+         bStopped = true ;
+         break ;
+      }
    }
 
    return true ;
@@ -128,11 +141,13 @@ ChainCurves::GetChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
 
 //----------------------------------------------------------------------------
 bool
-ChainCurves::GetReverseChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart, bool bStopOnFork,
-                                       INTVECTOR& vIds)
+ChainCurves::GetReverseChainFromPoint( const Point3d& ptStart, const Vector3d& vtStart,
+                                       const Point3d& ptStop,  bool bHaltOnFork,
+                                       INTVECTOR& vIds, bool& bStopped)
 {
   // pulisco il risultato
    vIds.clear() ;
+   bStopped = false ;
    m_bIsFork = false ;
    m_vFork.clear() ;
 
@@ -142,7 +157,7 @@ ChainCurves::GetReverseChainFromPoint( const Point3d& ptStart, const Vector3d& v
    int nPrev ;
    INTVECTOR vPrev ;
    while ( m_PointGrid.Find( ptCurr, m_dToler, vPrev)  &&
-           ChoosePrev( vtCurr, vPrev, bStopOnFork, nPrev)) {
+           ChoosePrev( vtCurr, vPrev, bHaltOnFork, nPrev)) {
      // recupero indice e verso
       int nId = abs( nPrev) - 1 ;
       bool bEquiv = ( nPrev < 0) ;
@@ -153,6 +168,11 @@ ChainCurves::GetReverseChainFromPoint( const Point3d& ptStart, const Vector3d& v
      // determino il prossimo inizio
       ptCurr = bEquiv ? m_vCrvData[nId].ptStart : m_vCrvData[nId].ptEnd ;
       vtCurr = bEquiv ? m_vCrvData[nId].vtStart : - m_vCrvData[nId].vtEnd ;
+     // verifico se sono arrivato al punto di stop
+      if ( AreSamePointEpsilon( ptCurr, ptStop, m_dToler)) {
+         bStopped = true ;
+         break ;
+      }
    }
 
    return true ;
@@ -221,7 +241,7 @@ ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int&
 
 //----------------------------------------------------------------------------
 bool
-ChainCurves::ChooseNext( const Vector3d& vtCurr, const INTVECTOR& vNext, bool bStopOnFork, int& nNext)
+ChainCurves::ChooseNext( const Vector3d& vtCurr, const INTVECTOR& vNext, bool bHaltOnFork, int& nNext)
 {
   // cerco la direzione più vicina
    int nI = - 1 ;
@@ -236,7 +256,7 @@ ChainCurves::ChooseNext( const Vector3d& vtCurr, const INTVECTOR& vNext, bool bS
          continue ;
      // incremento contatore indice entità tra cui scegliere
       ++ nF ;
-      if ( bStopOnFork)
+      if ( bHaltOnFork)
          m_vFork.push_back( vNext[i]) ;
      // determino scarto angolare
       Vector3d vtDir = ( bEquiv ? m_vCrvData[nId].vtStart : - m_vCrvData[nId].vtEnd) ;
@@ -254,7 +274,7 @@ ChainCurves::ChooseNext( const Vector3d& vtCurr, const INTVECTOR& vNext, bool bS
    }
 
   // se richiesto arresto su biforcazione e trovata biforcazione
-   if ( bStopOnFork  &&  nF > 1) {
+   if ( bHaltOnFork  &&  nF > 1) {
       m_bIsFork = true ;
       return false ;
    }
@@ -267,7 +287,7 @@ ChainCurves::ChooseNext( const Vector3d& vtCurr, const INTVECTOR& vNext, bool bS
 
 //----------------------------------------------------------------------------
 bool
-ChainCurves::ChoosePrev( const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bStopOnFork, int& nPrev)
+ChainCurves::ChoosePrev( const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bHaltOnFork, int& nPrev)
 {
   // cerco la direzione più vicina
    int nI = - 1 ;
@@ -282,7 +302,7 @@ ChainCurves::ChoosePrev( const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bS
          continue ;
      // incremento contatore indice entità tra cui scegliere
       ++ nF ;
-      if ( bStopOnFork)
+      if ( bHaltOnFork)
          m_vFork.push_back( vPrev[i]) ;
      // determino scarto angolare
       Vector3d vtDir = ( bEquiv ? m_vCrvData[nId].vtEnd : - m_vCrvData[nId].vtStart) ;
@@ -300,7 +320,7 @@ ChainCurves::ChoosePrev( const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bS
    }
 
   // se richiesto arresto su biforcazione e trovata biforcazione
-   if ( bStopOnFork  &&  nF > 1) {
+   if ( bHaltOnFork  &&  nF > 1) {
       m_bIsFork = true ;
       return false ;
    }
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index 7875c0c..a4a2790 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -5115,7 +5115,7 @@ GdbExecutor::CurveCopyByChain( const STRVECTOR& vsParams)
    }
   // recupero i percorsi concatenati
    INTVECTOR vIds ;
-   while ( chainC.GetChainFromNear( ptNearStart, vIds)) {
+   while ( chainC.GetChainFromNear( ptNearStart, false, vIds)) {
      // creo una curva composita
       PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
       if ( IsNull( pCrvCompo))
diff --git a/PointGrid3d.cpp b/PointGrid3d.cpp
index ddf6ad0..4f23c55 100644
--- a/PointGrid3d.cpp
+++ b/PointGrid3d.cpp
@@ -292,7 +292,7 @@ PointGrid3d::FindNearest( const Point3d& ptTest, INTVECTOR& vnIds)
                     // se distanza inferiore al minimo, aggiorno...
                      double dSqDist = SqDist( (*MMrange.first).second.first, ptTest) ;
                     // altro punto con la stessa minima distanza già trovata
-                     if ( bFound  &&  fabs( dSqDist - dSqMinDist) < 2 * dMinDist * NEAR_TOL) {
+                     if ( bFound  &&  fabs( dSqDist - dSqMinDist) < 2 * dMinDist * NEAR_TOL + NEAR_TOL * NEAR_TOL) {
                        // inserisco il punto nel vettore dei risultati
                         vnIds.push_back( (*MMrange.first).second.second) ;
                      }